Coverage Report

Created: 2026-08-14 06:45

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/wireshark/epan/dissectors/packet-isup.c
Line
Count
Source
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/osi-utils.h>
45
#include <epan/reassemble.h>
46
#include <epan/to_str.h>
47
#include <epan/media_params.h>
48
#include <epan/tfs.h>
49
#include <epan/unit_strings.h>
50
51
#include <wsutil/array.h>
52
#include "packet-q931.h"
53
#include "packet-isup.h"
54
#include "packet-e164.h"
55
#include "packet-charging_ase.h"
56
#include "packet-mtp3.h"
57
#include "packet-media-type.h"
58
#include "packet-sctp.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
839
#define ISUP_ITU_STANDARD_VARIANT 0
68
16
#define ISUP_FRENCH_VARIANT       1
69
16
#define ISUP_ISRAELI_VARIANT      2
70
204
#define ISUP_RUSSIAN_VARIANT      3
71
16
#define ISUP_JAPAN_VARIANT        4
72
16
#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
13.8k
#define ASCII_NUMBER_DELTA              0x30
79
6.52k
#define ASCII_LETTER_DELTA              0x37
80
81
/* Definition of protocol field values und lengths */
82
83
/* Definition of Message Types */
84
120
#define MESSAGE_TYPE_INITIAL_ADDR        1
85
14
#define MESSAGE_TYPE_SUBSEQ_ADDR         2
86
65
#define MESSAGE_TYPE_INFO_REQ            3
87
16
#define MESSAGE_TYPE_INFO                4
88
2
#define MESSAGE_TYPE_CONTINUITY          5
89
28
#define MESSAGE_TYPE_ADDR_CMPL           6
90
103
#define MESSAGE_TYPE_CONNECT             7
91
59
#define MESSAGE_TYPE_FORW_TRANS          8
92
5
#define MESSAGE_TYPE_ANSWER              9
93
14
#define MESSAGE_TYPE_RELEASE            12
94
37
#define MESSAGE_TYPE_SUSPEND            13
95
16
#define MESSAGE_TYPE_RESUME             14
96
4
#define MESSAGE_TYPE_REL_CMPL           16
97
2
#define MESSAGE_TYPE_CONT_CHECK_REQ     17
98
2
#define MESSAGE_TYPE_RESET_CIRCUIT      18
99
2
#define MESSAGE_TYPE_BLOCKING           19
100
1
#define MESSAGE_TYPE_UNBLOCKING         20
101
2
#define MESSAGE_TYPE_BLOCK_ACK          21
102
2
#define MESSAGE_TYPE_UNBLOCK_ACK        22
103
1
#define MESSAGE_TYPE_CIRC_GRP_RST       23
104
2
#define MESSAGE_TYPE_CIRC_GRP_BLCK      24
105
2
#define MESSAGE_TYPE_CIRC_GRP_UNBL      25
106
2
#define MESSAGE_TYPE_CIRC_GRP_BL_ACK    26
107
2
#define MESSAGE_TYPE_CIRC_GRP_UNBL_ACK  27
108
6
#define MESSAGE_TYPE_FACILITY_REQ       31
109
19
#define MESSAGE_TYPE_FACILITY_ACC       32
110
18
#define MESSAGE_TYPE_FACILITY_REJ       33
111
2
#define MESSAGE_TYPE_LOOP_BACK_ACK      36
112
107
#define MESSAGE_TYPE_PASS_ALONG         40
113
2
#define MESSAGE_TYPE_CIRC_GRP_RST_ACK   41
114
4
#define MESSAGE_TYPE_CIRC_GRP_QRY       42
115
8
#define MESSAGE_TYPE_CIRC_GRP_QRY_RSP   43
116
3
#define MESSAGE_TYPE_CALL_PROGRSS       44
117
17
#define MESSAGE_TYPE_USER2USER_INFO     45
118
2
#define MESSAGE_TYPE_UNEQUIPPED_CIC     46
119
4
#define MESSAGE_TYPE_CONFUSION          47
120
2
#define MESSAGE_TYPE_OVERLOAD           48
121
129
#define MESSAGE_TYPE_CHARGE_INFO        49
122
10
#define MESSAGE_TYPE_NETW_RESRC_MGMT    50
123
14
#define MESSAGE_TYPE_FACILITY           51
124
11
#define MESSAGE_TYPE_USER_PART_TEST     52
125
32
#define MESSAGE_TYPE_USER_PART_AVAIL    53
126
3
#define MESSAGE_TYPE_IDENT_REQ          54
127
6
#define MESSAGE_TYPE_IDENT_RSP          55
128
11
#define MESSAGE_TYPE_SEGMENTATION       56
129
2
#define MESSAGE_TYPE_LOOP_PREVENTION    64
130
3
#define MESSAGE_TYPE_APPLICATION_TRANS  65
131
5
#define MESSAGE_TYPE_PRE_RELEASE_INFO   66
132
1
#define MESSAGE_TYPE_SUBSEQUENT_DIR_NUM 67
133
134
0
#define ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES_ACK  0xE9
135
0
#define ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES      0xEA
136
0
#define ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST_RSP 0xEB
137
0
#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
0
#define FRENCH_CHARGING_PULSE 0xe1
225
0
#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
0
#define ISRAELI_BACKWARD_CHARGING 232
313
0
#define ISRAELI_TRAFFIC_CHANGE 233
314
0
#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
0
#define RUSSIAN_CLEAR_CALLING_LINE 252
403
0
#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
0
#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_APPLICATION_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
0
#define JAPAN_ISUP_PARAM_CALLED_DIRECTORY_NUMBER         125 /* 7D */
1269
0
#define JAPAN_ISUP_PARAM_REDIRECT_FORWARD_INF            139 /* 8B */
1270
0
#define JAPAN_ISUP_PARAM_REDIRECT_BACKWARD_INF           140 /* 8C */
1271
0
#define JAPAN_ISUP_PARAM_EMERGENCY_CALL_IND              215 /* D7 */
1272
0
#define JAPAN_ISUP_PARAM_EMERGENCY_CALL_INF_IND          236 /* EC */
1273
0
#define JAPAN_ISUP_PARAM_NETWORK_POI_CA                  238 /* EE */
1274
0
#define JAPAN_ISUP_PARAM_TYPE_CARRIER_INFO               241 /* F1 */
1275
0
#define JAPAN_ISUP_PARAM_CHARGE_INF_DELAY                242 /* F2 */
1276
1277
0
#define JAPAN_ISUP_PARAM_TYPE_ADDITONAL_USER_CAT         243 /* F3 */
1278
0
#define JAPAN_ISUP_PARAM_REASON_FOR_CLIP_FAIL            245 /* F5 */
1279
0
#define JAPAN_ISUP_PARAM_TYPE_CONTRACTOR_NUMBER          249 /* F9 */
1280
0
#define JAPAN_ISUP_PARAM_TYPE_CHARGE_INF_TYPE            250 /* FA */
1281
0
#define JAPAN_ISUP_PARAM_TYPE_CHARGE_INF                 251 /* FB */
1282
0
#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_APPLICATION_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_APPLICATION_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
450
#define CIC_LENGTH                             2
1584
1.65k
#define BICC_CIC_LENGTH                        4
1585
1.62k
#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
41.2k
#define MAXDIGITS                              32 /* Max number of address digits */
1590
#define MAXGNAME                               15 /* Max number of characters in generic name */
1591
1592
22.6k
#define PARAMETER_TYPE_LENGTH                  1
1593
1.07k
#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
18.5k
#define PARAMETER_LENGTH_IND_LENGTH            1
1599
23
#define ACCESS_DELIVERY_INFO_LENGTH            1
1600
24
#define AUTO_CONGEST_LEVEL_LENGTH              1
1601
583
#define BACKWARD_CALL_IND_LENGTH               2
1602
13
#define BACKWARD_GVNS_LENGTH                   1
1603
15
#define CALL_DIV_INFO_LENGTH                   1
1604
40
#define CALL_DIV_TREATMENT_IND_LENGTH          1
1605
32
#define CALL_HISTORY_INFO_LENGTH               2
1606
32
#define CALL_OFFERING_TREATMENT_IND_LENGTH     1
1607
#define CALL_REFERENCE_LENGTH                  5
1608
15
#define CALL_TRANSFER_REF_LENGTH               1
1609
548
#define CALLING_PRTYS_CATEGORY_LENGTH          1
1610
#define CCSS_LENGTH                            1
1611
#define CIRCUIT_ASSIGNMENT_MAP_LENGTH          5
1612
75
#define CIRC_GRP_SV_MSG_TYPE_LENGTH            1
1613
#define CLOSED_USR_GRP_INTERLOCK_CODE_LENGTH   4
1614
13
#define COLLECT_CALL_REQUEST_LENGTH            1
1615
28
#define CONFERENCE_TREATMENT_IND_LENGTH        1
1616
#define CONNECTION_REQUEST_LENGTH              7
1617
53
#define CONTINUITY_IND_LENGTH                  1
1618
#define ECHO_CONTROL_INFO_LENGTH               1
1619
#define END_OF_OPT_PART_LENGTH                 1
1620
79
#define EVENT_INFO_LENGTH                      1
1621
129
#define FACILITY_IND_LENGTH                    1
1622
544
#define FORWARD_CALL_IND_LENGTH                2
1623
#define GENERIC_NOTIFICATION_IND_LENGTH        1
1624
16
#define HOP_COUNTER_LENGTH                     1
1625
0
#define ORIG_LINE_INFO_LENGTH                  1
1626
186
#define INFO_IND_LENGTH                        2
1627
333
#define INFO_REQUEST_IND_LENGTH                2
1628
26
#define LOOP_PREVENTION_IND_LENGTH             1
1629
14
#define MCID_REQUEST_IND_LENGTH                1
1630
22
#define MCID_RESPONSE_IND_LENGTH               1
1631
#define MLPP_PRECEDENCE_LENGTH                 1
1632
541
#define NATURE_OF_CONNECTION_IND_LENGTH        1
1633
60
#define NETWORK_MANAGEMENT_CONTROLS_LENGTH     1
1634
27
#define OPTIONAL_BACKWARD_CALL_IND_LENGTH      1
1635
89
#define OPTIONAL_FORWARD_CALL_IND_LENGTH       1
1636
20
#define ORIGINAL_ISC_POINT_CODE_LENGTH         2
1637
36
#define PROPAGATION_DELAY_COUNT_LENGTH         2
1638
#define REDIRECTION_NUMBER_LENGTH              2
1639
8
#define REDIRECTION_INFO_LENGTH                2
1640
12
#define REDIRECTION_NUMBER_RESTRICTION_LENGTH  1
1641
14
#define SIGNALLING_POINT_CODE_LENGTH           2
1642
239
#define SUSPEND_RESUME_IND_LENGTH              1
1643
696
#define TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH 1
1644
95
#define TRANSMISSION_MEDIUM_RQMT_PRIME_LENGTH  1
1645
#define TRANSMISSION_MEDIUM_USED_LENGTH        1
1646
18
#define UID_ACTION_IND_LENGTH                  1
1647
8
#define UID_CAPABILITY_IND_LENGTH              1
1648
#define USER_TELESERVICE_INFO_LENGTH           2
1649
#define USER_TO_USER_IND_LENGTH                1
1650
116
#define RANGE_LENGTH                           1
1651
1652
0
#define CVR_RESP_IND_LENGTH                    1
1653
0
#define CG_CHAR_IND_LENGTH                     1
1654
#define CI_NAME_IND                           28
1655
#define CLLI_CODE_LENGTH                      13
1656
1657
117
#define CALL_ID_LENGTH        3 /* for parameter Call Reference */
1658
279
#define SPC_LENGTH            2 /* for parameter Call Reference, Connection request */
1659
240
#define LOCAL_REF_LENGTH      3 /* for parameter Connection request */
1660
240
#define PROTOCOL_CLASS_LENGTH 1 /* for parameter Connection request */
1661
120
#define CREDIT_LENGTH         1 /* for parameter Connection request */
1662
1663
450
#define CIC_OFFSET            0
1664
1.65k
#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
16
#define ISUP_ODD_EVEN_MASK                       0x80
2053
48
#define ISUP_NATURE_OF_ADDRESS_IND_MASK          0x7F
2054
16
#define ISUP_INN_MASK                            0x80
2055
16
#define ISUP_NI_MASK                             0x80
2056
16
#define ISUP_NUMBERING_PLAN_IND_MASK             0x70
2057
16
#define ISUP_ADDRESS_PRESENTATION_RESTR_IND_MASK 0x0C
2058
32
#define ISUP_SCREENING_IND_MASK                  0x03
2059
9.84k
#define ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK       0x0F
2060
9.79k
#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
35
#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
0
#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
0
#define CARRIER_INFO_TYPE_OF_CARRIER_POIHIE      0xFC
2274
0
#define CARRIER_INFO_TYPE_OF_CARRIER_POICA       0xFD
2275
0
#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
0
#define CHARGE_AREA_NAT_INFO_MA                0
2355
0
#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
213
#define A_8BIT_MASK       0x01
2711
48
#define B_8BIT_MASK       0x02
2712
32
#define C_8BIT_MASK       0x04
2713
32
#define D_8BIT_MASK       0x08
2714
64
#define E_8BIT_MASK       0x10
2715
#define F_8BIT_MASK       0x20
2716
16
#define G_8BIT_MASK       0x40
2717
1.05k
#define H_8BIT_MASK       0x80
2718
2719
4.12k
#define BA_8BIT_MASK      0x03
2720
48
#define CB_8BIT_MASK      0x06
2721
3.89k
#define DC_8BIT_MASK      0x0C
2722
32
#define ED_8BIT_MASK      0x18
2723
48
#define FE_8BIT_MASK      0x30
2724
64
#define GF_8BIT_MASK      0x60
2725
32
#define HG_8BIT_MASK      0xC0
2726
118
#define GFE_8BIT_MASK     0x70
2727
16
#define HGF_8BIT_MASK     0xE0
2728
410
#define DCBA_8BIT_MASK    0x0F
2729
16
#define EDCBA_8BIT_MASK   0x1F
2730
394
#define HGFE_8BIT_MASK    0xF0
2731
169
#define GFEDCBA_8BIT_MASK 0x7F
2732
32
#define FEDCBA_8BIT_MASK  0x3F
2733
2734
32
#define A_16BIT_MASK    0x0100
2735
16
#define B_16BIT_MASK    0x0200
2736
16
#define C_16BIT_MASK    0x0400
2737
32
#define D_16BIT_MASK    0x0800
2738
48
#define E_16BIT_MASK    0x1000
2739
48
#define F_16BIT_MASK    0x2000
2740
16
#define G_16BIT_MASK    0x4000
2741
32
#define H_16BIT_MASK    0x8000
2742
32
#define I_16BIT_MASK    0x0001
2743
48
#define J_16BIT_MASK    0x0002
2744
32
#define K_16BIT_MASK    0x0004
2745
16
#define L_16BIT_MASK    0x0008
2746
32
#define M_16BIT_MASK    0x0010
2747
32
#define N_16BIT_MASK    0x0020
2748
#define O_16BIT_MASK    0x0040
2749
#define P_16BIT_MASK    0x0080
2750
2751
32
#define BA_16BIT_MASK   0x0300
2752
32
#define CB_16BIT_MASK   0x0600
2753
16
#define DC_16BIT_MASK   0x0C00
2754
16
#define FE_16BIT_MASK   0x3000
2755
64
#define HG_16BIT_MASK   0xC000
2756
32
#define KJ_16BIT_MASK   0x0006
2757
32
#define PO_16BIT_MASK   0x00C0
2758
2759
16
#define CBA_16BIT_MASK  0x0700
2760
16
#define KJI_16BIT_MASK  0x0007
2761
16
#define HGFE_16BIT_MASK 0xF000
2762
16
#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_message_type_ansi;
2792
static int hf_isup_message_type_french;
2793
static int hf_isup_message_type_israeli;
2794
static int hf_isup_message_type_russian;
2795
static int hf_isup_message_type_japan;
2796
static int hf_isup_parameter_type;
2797
static int hf_isup_parameter_value;
2798
static int hf_isup_mand_parameter_type;
2799
static int hf_isup_opt_parameter_type;
2800
static int hf_isup_parameter_length;
2801
static int hf_isup_mandatory_variable_parameter_pointer;
2802
static int hf_isup_pointer_to_start_of_optional_part;
2803
2804
static int hf_isup_cvr_rsp_ind;
2805
static int hf_isup_cvr_cg_car_ind;
2806
static int hf_isup_cvr_cg_double_seize;
2807
static int hf_isup_cvr_cg_alarm_car_ind;
2808
static int hf_isup_cvr_cont_chk_ind;
2809
2810
static int hf_isup_satellite_indicator;
2811
static int hf_isup_continuity_check_indicator;
2812
static int hf_bicc_continuity_check_indicator;
2813
static int hf_isup_echo_control_device_indicator;
2814
2815
static int hf_isup_forw_call_natnl_inatnl_call_indicator;
2816
static int hf_isup_forw_call_end_to_end_method_indicator;
2817
static int hf_bicc_forw_call_end_to_end_method_indicator;
2818
static int hf_isup_forw_call_interworking_indicator;
2819
static int hf_isup_forw_call_end_to_end_info_indicator;
2820
static int hf_bicc_forw_call_end_to_end_info_indicator;
2821
static int hf_isup_forw_call_isdn_user_part_indicator;
2822
static int hf_bicc_forw_call_isdn_user_part_indicator;
2823
static int hf_isup_forw_call_preferences_indicator;
2824
static int hf_bicc_forw_call_preferences_indicator;
2825
static int hf_isup_forw_call_isdn_access_indicator;
2826
static int hf_isup_forw_call_ported_num_trans_indicator;
2827
static int hf_isup_forw_call_qor_attempt_indicator;
2828
static int hf_isup_forw_call_sccp_method_indicator;
2829
static int hf_bicc_forw_call_sccp_method_indicator;
2830
2831
static int hf_isup_calling_partys_category;
2832
static int hf_russian_isup_calling_partys_category;
2833
2834
static int hf_isup_transmission_medium_requirement;
2835
2836
static int hf_isup_odd_even_indicator;
2837
static int hf_isup_called_party_nature_of_address_indicator;
2838
static int hf_isup_calling_party_nature_of_address_indicator;
2839
static int hf_isup_inn_indicator;
2840
static int hf_isup_ni_indicator;
2841
static int hf_isup_numbering_plan_indicator;
2842
static int hf_isup_address_presentation_restricted_indicator;
2843
static int hf_isup_screening_indicator;
2844
static int hf_isup_screening_indicator_enhanced;
2845
static int hf_isup_called_party_odd_address_signal_digit;
2846
static int hf_isup_calling_party_odd_address_signal_digit;
2847
static int hf_isup_called_party_even_address_signal_digit;
2848
static int hf_isup_calling_party_even_address_signal_digit;
2849
2850
static int hf_isup_generic_name_presentation;
2851
static int hf_isup_generic_name_availability;
2852
static int hf_isup_generic_name_type;
2853
static int hf_isup_generic_name_ia5;
2854
2855
static int hf_isup_OECD_inf_ind;
2856
static int hf_isup_IECD_inf_ind;
2857
static int hf_isup_OECD_req_ind;
2858
static int hf_isup_IECD_req_ind;
2859
2860
static int hf_isup_calling_party_address_request_indicator;
2861
static int hf_isup_info_req_holding_indicator;
2862
static int hf_isup_calling_partys_category_request_indicator;
2863
static int hf_isup_charge_information_request_indicator;
2864
static int hf_isup_charge_number_nature_of_address_indicator;
2865
static int hf_isup_malicious_call_identification_request_indicator;
2866
2867
static int hf_isup_calling_party_address_response_indicator;
2868
static int hf_isup_hold_provided_indicator;
2869
static int hf_isup_calling_partys_category_response_indicator;
2870
static int hf_isup_charge_information_response_indicator;
2871
static int hf_isup_solicited_indicator;
2872
2873
static int hf_isup_continuity_indicator;
2874
2875
static int hf_isup_backw_call_charge_ind;
2876
static int hf_isup_backw_call_called_partys_status_ind;
2877
static int hf_isup_backw_call_called_partys_category_ind;
2878
static int hf_isup_backw_call_end_to_end_method_ind;
2879
static int hf_bicc_backw_call_end_to_end_method_ind;
2880
static int hf_isup_backw_call_interworking_ind;
2881
static int hf_isup_backw_call_end_to_end_info_ind;
2882
static int hf_bicc_backw_call_end_to_end_info_ind;
2883
static int hf_isup_backw_call_iam_seg_ind;
2884
static int hf_isup_backw_call_isdn_user_part_ind;
2885
static int hf_bicc_backw_call_isdn_user_part_ind;
2886
static int hf_isup_backw_call_holding_ind;
2887
static int hf_isup_backw_call_isdn_access_ind;
2888
static int hf_isup_backw_call_echo_control_device_ind;
2889
static int hf_isup_backw_call_sccp_method_ind;
2890
static int hf_bicc_backw_call_sccp_method_ind;
2891
2892
static int hf_isup_cause_indicator;
2893
static int hf_ansi_isup_cause_indicator;
2894
2895
static int hf_isup_suspend_resume_indicator;
2896
2897
static int hf_isup_range_indicator;
2898
static int hf_isup_bitbucket;
2899
static int hf_isup_cgs_message_type;
2900
2901
static int hf_isup_mtc_blocking_state1;
2902
static int hf_isup_mtc_blocking_state2;
2903
static int hf_isup_call_proc_state;
2904
static int hf_isup_hw_blocking_state;
2905
2906
static int hf_isup_event_ind;
2907
static int hf_isup_event_presentation_restricted_ind;
2908
2909
static int hf_isup_cug_call_ind;
2910
static int hf_isup_simple_segmentation_ind;
2911
static int hf_isup_connected_line_identity_request_ind;
2912
2913
static int hf_isup_redirecting_ind;
2914
static int hf_isup_original_redirection_reason;
2915
static int hf_isup_redirection_counter;
2916
static int hf_isup_redirection_reason;
2917
2918
static int hf_isup_type_of_network_identification;
2919
static int hf_isup_network_identification_plan;
2920
2921
static int hf_isup_map_type;
2922
2923
static int hf_isup_automatic_congestion_level;
2924
2925
static int hf_isup_inband_information_ind;
2926
static int hf_isup_call_diversion_may_occur_ind;
2927
static int hf_isup_mlpp_user_ind;
2928
2929
static int hf_isup_UUI_type;
2930
static int hf_isup_UUI_req_service1;
2931
static int hf_isup_UUI_req_service2;
2932
static int hf_isup_UUI_req_service3;
2933
static int hf_isup_UUI_res_service1;
2934
static int hf_isup_UUI_res_service2;
2935
static int hf_isup_UUI_res_service3;
2936
static int hf_isup_notification_indicator;
2937
static int hf_isup_UUI_network_discard_ind;
2938
static int hf_isup_access_delivery_ind;
2939
2940
static int hf_isup_transmission_medium_requirement_prime;
2941
2942
static int hf_isup_loop_prevention_response_ind;
2943
2944
static int hf_isup_temporary_alternative_routing_ind;
2945
static int hf_isup_extension_ind;
2946
2947
static int hf_isup_call_to_be_diverted_ind;
2948
2949
static int hf_isup_call_to_be_offered_ind;
2950
2951
static int hf_isup_conference_acceptance_ind;
2952
2953
static int hf_isup_transit_at_intermediate_exchange_ind;
2954
static int hf_isup_Release_call_ind;
2955
static int hf_isup_Send_notification_ind;
2956
static int hf_isup_Discard_message_ind_value;
2957
static int hf_isup_Discard_parameter_ind;
2958
static int hf_isup_Pass_on_not_possible_indicator;
2959
static int hf_isup_pass_on_not_possible_indicator2;
2960
static int hf_isup_Broadband_narrowband_interworking_ind;
2961
static int hf_isup_Broadband_narrowband_interworking_ind2;
2962
2963
static int hf_isup_app_cont_ident;
2964
static int hf_isup_app_Send_notification_ind;
2965
static int hf_isup_apm_segmentation_ind;
2966
static int hf_isup_apm_si_ind;
2967
static int hf_isup_apm_slr;
2968
static int hf_isup_orig_addr_len;
2969
static int hf_isup_dest_addr_len;
2970
static int hf_isup_app_Release_call_ind;
2971
static int hf_isup_cause_location;
2972
2973
static int hf_ansi_isup_coding_standard;
2974
static int hf_ansi_isup_spare_b7;
2975
static int hf_ansi_isup_type_of_nw_id;
2976
static int hf_ansi_isup_nw_id_plan;
2977
static int hf_ansi_isup_tns_nw_id_plan;
2978
static int hf_ansi_isup_nw_id;
2979
static int hf_ansi_isup_circuit_code;
2980
2981
static int hf_length_indicator;
2982
static int hf_afi;
2983
static int hf_bicc_nsap_dsp;
2984
static int hf_bicc_nsap_dsp_length;
2985
static int hf_bat_ase_identifier;
2986
2987
static int hf_Action_Indicator;
2988
2989
static int hf_Instruction_ind_for_general_action;
2990
2991
static int hf_Send_notification_ind_for_general_action;
2992
2993
static int hf_Instruction_ind_for_pass_on_not_possible;
2994
2995
static int hf_Send_notification_ind_for_pass_on_not_possible;
2996
static int hf_BCTP_Version_Indicator;
2997
static int hf_Tunnelled_Protocol_Indicator;
2998
static int hf_TPEI;
2999
static int hf_BVEI;
3000
static int hf_bncid;
3001
static int hf_bat_ase_biwfa;
3002
static int hf_characteristics;
3003
3004
static int hf_Organization_Identifier;
3005
static int hf_codec_type;
3006
static int hf_etsi_codec_type;
3007
static int hf_active_code_set;
3008
static int hf_active_code_set_12_2;
3009
static int hf_active_code_set_10_2;
3010
static int hf_active_code_set_7_95;
3011
static int hf_active_code_set_7_40;
3012
static int hf_active_code_set_6_70;
3013
static int hf_active_code_set_5_90;
3014
static int hf_active_code_set_5_15;
3015
static int hf_active_code_set_4_75;
3016
static int hf_supported_code_set;
3017
static int hf_supported_code_set_12_2;
3018
static int hf_supported_code_set_10_2;
3019
static int hf_supported_code_set_7_95;
3020
static int hf_supported_code_set_7_40;
3021
static int hf_supported_code_set_6_70;
3022
static int hf_supported_code_set_5_90;
3023
static int hf_supported_code_set_5_15;
3024
static int hf_supported_code_set_4_75;
3025
static int hf_optimisation_mode;
3026
static int hf_max_codec_modes;
3027
static int hf_bearer_control_tunneling;
3028
static int hf_Local_BCU_ID;
3029
static int hf_late_cut_through_cap_ind;
3030
static int hf_bat_ase_signal;
3031
static int hf_bat_ase_duration;
3032
static int hf_bat_ase_bearer_redir_ind;
3033
static int hf_bat_ase_default;
3034
static int hf_BAT_ASE_Comp_Report_Reason;
3035
static int hf_BAT_ASE_Comp_Report_ident;
3036
static int hf_BAT_ASE_Comp_Report_diagnostic;
3037
static int hf_nsap_ipv4_addr;
3038
static int hf_nsap_ipv6_addr;
3039
static int hf_iana_icp;
3040
3041
static int hf_isup_geo_loc_presentation_restricted_ind;
3042
static int hf_isup_geo_loc_screening_ind;
3043
3044
static int hf_isup_apm_msg_fragments;
3045
static int hf_isup_apm_msg_fragment;
3046
static int hf_isup_apm_msg_fragment_overlap;
3047
static int hf_isup_apm_msg_fragment_overlap_conflicts;
3048
static int hf_isup_apm_msg_fragment_multiple_tails;
3049
static int hf_isup_apm_msg_fragment_too_long_fragment;
3050
static int hf_isup_apm_msg_fragment_error;
3051
static int hf_isup_apm_msg_fragment_count;
3052
static int hf_isup_apm_msg_reassembled_in;
3053
static int hf_isup_apm_msg_reassembled_length;
3054
3055
/* national parameters */
3056
static int hf_isup_french_coll_field;
3057
static int hf_isup_french_msg_num;
3058
3059
static int hf_isup_israeli_charging_message_indicators_current;
3060
static int hf_isup_israeli_charging_message_indicators_next;
3061
static int hf_isup_israeli_current_rate;
3062
static int hf_isup_israeli_time_indicator;
3063
static int hf_isup_israeli_next_rate;
3064
3065
static int hf_japan_isup_redirect_capability;
3066
static int hf_japan_isup_redirect_counter;
3067
static int hf_japan_isup_rfi_info_type;
3068
static int hf_japan_isup_rfi_info_len;
3069
static int hf_japan_isup_perf_redir_reason;
3070
static int hf_japan_isup_redir_pos_ind;
3071
static int hf_japan_isup_inv_redir_reason;
3072
static int hf_japan_isup_bwd_info_type;
3073
static int hf_japan_isup_tag_len;
3074
static int hf_japan_isup_hold_at_emerg_call_disc_ind;
3075
static int hf_japan_isup_emerg_call_type;
3076
static int hf_japan_isup_add_user_cat_type;
3077
static int hf_japan_isup_type_1_add_fixed_serv_inf;
3078
static int hf_japan_isup_type_1_add_mobile_serv_inf;
3079
static int hf_japan_isup_type_2_add_mobile_serv_inf;
3080
static int hf_japan_isup_type_3_add_mobile_serv_inf;
3081
static int hf_japan_isup_reason_for_clip_fail;
3082
static int hf_japan_isup_contractor_number;
3083
3084
static int hf_isup_carrier_info_iec;
3085
/*static int hf_isup_carrier_info_cat_of_carrier;*/
3086
/*static int hf_isup_carrier_info_type_of_carrier_info;*/
3087
static int hf_japan_isup_carrier_info_length;
3088
static int hf_isup_carrier_info_odd_no_digits;
3089
static int hf_isup_carrier_info_even_no_digits;
3090
static int hf_isup_carrier_info_ca_odd_no_digits;
3091
static int hf_isup_carrier_info_ca_even_no_digits;
3092
static int hf_isup_carrier_info_poi_entry_HEI;
3093
static int hf_isup_carrier_info_poi_exit_HEI;
3094
3095
static int hf_japan_isup_charge_delay_type;
3096
static int hf_japan_isup_charge_info_type;
3097
static int hf_japan_isup_sig_elem_type;
3098
static int hf_japan_isup_activation_id;
3099
static int hf_japan_isup_op_cls;
3100
static int hf_japan_isup_op_type;
3101
static int hf_japan_isup_charging_party_type;
3102
static int hf_japan_isup_utp;
3103
static int hf_japan_isup_crci1;
3104
static int hf_japan_isup_crci2;
3105
static int hf_japan_isup_crci1_len;
3106
static int hf_japan_isup_iu;
3107
static int hf_japan_isup_dcr;
3108
static int hf_japan_isup_ecr;
3109
static int hf_japan_isup_ncr;
3110
static int hf_japan_isup_scr;
3111
static int hf_japan_isup_collecting_method;
3112
static int hf_japan_isup_tariff_rate_pres;
3113
3114
static int hf_japan_isup_charge_area_nat_of_info_value;
3115
static int hf_japan_isup_charging_info_nc_odd_digits;
3116
static int hf_japan_isup_charging_info_nc_even_digits;
3117
static int hf_isup_charging_info_maca_odd_digits;
3118
static int hf_isup_charging_info_maca_even_digits;
3119
3120
/* Generated from convert_proto_tree_add_text.pl */
3121
static int hf_isup_protocol_class;
3122
static int hf_isup_geo_loc_shape_description;
3123
static int hf_isup_geo_loc_shape;
3124
static int hf_isup_ccss_call_indicator;
3125
static int hf_isup_charged_party_identification;
3126
static int hf_isup_forward_gvns;
3127
static int hf_isup_idi;
3128
static int hf_isup_precedence_level;
3129
static int hf_isup_configuration_data;
3130
static int hf_isup_redirect_capability;
3131
static int hf_isup_credit;
3132
static int hf_isup_idp;
3133
static int hf_isup_apm_seg_indicator;
3134
static int hf_isup_user_service_information;
3135
static int hf_isup_tunnelled_protocol_data;
3136
static int hf_isup_mlpp_service_domain;
3137
static int hf_isup_uid_capability_indicators;
3138
static int hf_isup_call_identity;
3139
static int hf_isup_scf_id;
3140
static int hf_isup_call_diversion_information;
3141
static int hf_isup_display_information;
3142
static int hf_isup_call_history_info;
3143
static int hf_isup_remote_operations;
3144
static int hf_isup_user_to_user_info;
3145
static int hf_isup_address_digits;
3146
static int hf_isup_network_id;
3147
static int hf_isup_uid_action_indicators;
3148
static int hf_isup_dsp;
3149
static int hf_isup_instruction_indicators;
3150
static int hf_isup_circuit_assignment_map;
3151
static int hf_isup_collect_call_request_indicator;
3152
static int hf_isup_hop_counter;
3153
static int hf_isup_user_service_information_prime;
3154
static int hf_isup_message_compatibility_information;
3155
static int hf_isup_app_transport_param_field8;
3156
static int hf_isup_app_transport_param_field16;
3157
static int hf_isup_binary_code;
3158
static int hf_isup_local_reference;
3159
static int hf_isup_cause_indicators;
3160
static int hf_isup_backward_gvns;
3161
static int hf_isup_presentation_indicator;
3162
static int hf_isup_mcid_request_indicators;
3163
static int hf_isup_origination_isc_point_code;
3164
static int hf_isup_upgraded_parameter;
3165
static int hf_isup_generic_digits;
3166
static int hf_isup_diagnostic;
3167
static int hf_isup_network_specific_facility;
3168
static int hf_isup_app_transport_instruction_indicator;
3169
static int hf_isup_look_forward_busy;
3170
static int hf_isup_redirect_counter;
3171
static int hf_isup_correlation_id;
3172
static int hf_isup_network_identity;
3173
static int hf_isup_user_teleservice_information;
3174
static int hf_isup_mcid_response_indicators;
3175
static int hf_isup_apm_user_info_field;
3176
static int hf_isup_feature_code;
3177
static int hf_isup_number_qualifier_indicator;
3178
static int hf_isup_echo_control_information;
3179
static int hf_isup_network_id_length_indicator;
3180
static int hf_isup_unknown_organisation_identifier;
3181
static int hf_isup_originating_line_info;
3182
static int hf_isup_loop_prevention_indicator_type;
3183
static int hf_isup_signalling_point_code;
3184
static int hf_isup_call_transfer_identity;
3185
static int hf_isup_access_transport_parameter_field;
3186
static int hf_isup_propagation_delay_counter;
3187
static int hf_isup_number_different_meaning;
3188
3189
/* Initialize the subtree pointers */
3190
static int ett_isup;
3191
static int ett_isup_parameter;
3192
static int ett_isup_address_digits;
3193
static int ett_isup_carrier_info;
3194
static int ett_isup_pass_along_message;
3195
static int ett_isup_circuit_state_ind;
3196
static int ett_bat_ase;
3197
static int ett_bicc;
3198
static int ett_bat_ase_element;
3199
static int ett_bat_ase_iwfa;
3200
static int ett_acs;
3201
static int ett_scs;
3202
3203
static int ett_isup_apm_msg_fragment;
3204
static int ett_isup_apm_msg_fragments;
3205
static int ett_isup_range;
3206
static int ett_app_transport_fields;
3207
static int ett_app_transport;
3208
static int ett_apm_seg_indicator;
3209
static int ett_echo_control_information;
3210
static int ett_instruction_indicators;
3211
static int ett_message_compatibility_information;
3212
3213
static expert_field ei_isup_format_national_matter;
3214
static expert_field ei_isup_message_type_unknown;
3215
static expert_field ei_isup_not_dissected_yet;
3216
static expert_field ei_isup_message_type_no_optional_parameters;
3217
static expert_field ei_isup_status_subfield_not_present;
3218
static expert_field ei_isup_empty_number;
3219
static expert_field ei_isup_too_many_digits;
3220
static expert_field ei_isup_opt_par_length_err;
3221
3222
static dissector_handle_t bicc_handle;
3223
3224
static dissector_handle_t sdp_handle;
3225
static dissector_handle_t q931_ie_handle;
3226
3227
/* Declarations to desegment APM Messages */
3228
static bool isup_apm_desegment = true;
3229
3230
static const fragment_items isup_apm_msg_frag_items = {
3231
  /* Fragment subtrees */
3232
  &ett_isup_apm_msg_fragment,
3233
  &ett_isup_apm_msg_fragments,
3234
  /* Fragment fields */
3235
  &hf_isup_apm_msg_fragments,
3236
  &hf_isup_apm_msg_fragment,
3237
  &hf_isup_apm_msg_fragment_overlap,
3238
  &hf_isup_apm_msg_fragment_overlap_conflicts,
3239
  &hf_isup_apm_msg_fragment_multiple_tails,
3240
  &hf_isup_apm_msg_fragment_too_long_fragment,
3241
  &hf_isup_apm_msg_fragment_error,
3242
  &hf_isup_apm_msg_fragment_count,
3243
  /* Reassembled in field */
3244
  &hf_isup_apm_msg_reassembled_in,
3245
  /* Reassembled length field */
3246
  &hf_isup_apm_msg_reassembled_length,
3247
  /* Reassembled data field */
3248
  NULL,
3249
  /* Tag */
3250
  "ISUP APM Message fragments"
3251
};
3252
3253
static reassembly_table isup_apm_msg_reassembly_table;
3254
3255
/* Info for the tap that must be passed between procedures */
3256
static char *tap_called_number;
3257
static char *tap_calling_number;
3258
static uint8_t tap_cause_value;
3259
3260
/* ------------------------------------------------------------------
3261
  Mapping number to ASCII-character
3262
 ------------------------------------------------------------------ */
3263
static char number_to_char(int number)
3264
20.3k
{
3265
20.3k
  if (number < 10)
3266
13.8k
    return ((char) number + ASCII_NUMBER_DELTA);
3267
6.52k
  else
3268
6.52k
    return ((char) number + ASCII_LETTER_DELTA);
3269
20.3k
}
3270
3271
/* ------------------------------------------------------------------ */
3272
/* Dissectors for all used parameter types                            */
3273
/* ------------------------------------------------------------------ */
3274
/* argument tvbuff_t contains only parameter-specific length          */
3275
/* length indicator is already dissected in dissect_isup_message() or */
3276
/* dissect_isup_optional_parameter()                                  */
3277
/* ------------------------------------------------------------------ */
3278
/* ------------------------------------------------------------------
3279
 Dissector Parameter circuit validation response indicator
3280
 */
3281
3282
static void
3283
dissect_isup_cvr_response_ind_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
3284
0
{
3285
0
  uint8_t cvr_response_ind;
3286
3287
0
  cvr_response_ind = tvb_get_uint8(parameter_tvb, 0);
3288
0
  proto_tree_add_uint(parameter_tree, hf_isup_cvr_rsp_ind, parameter_tvb, 0, CVR_RESP_IND_LENGTH, cvr_response_ind);
3289
0
  proto_item_append_text(parameter_item, " : 0x%x", cvr_response_ind);
3290
3291
0
}
3292
3293
/* ------------------------------------------------------------------
3294
   Dissector Parameter circuit validation response - circuit group
3295
   characters
3296
*/
3297
static void
3298
dissect_isup_circuit_group_char_ind_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
3299
0
{
3300
0
  uint8_t cvr_cg_char_ind;
3301
3302
0
  cvr_cg_char_ind = tvb_get_uint8(parameter_tvb, 0);
3303
0
  proto_tree_add_uint(parameter_tree, hf_isup_cvr_cg_car_ind, parameter_tvb, 0, CG_CHAR_IND_LENGTH, cvr_cg_char_ind);
3304
0
  proto_tree_add_uint(parameter_tree, hf_isup_cvr_cg_double_seize, parameter_tvb, 0, CG_CHAR_IND_LENGTH, cvr_cg_char_ind);
3305
0
  proto_tree_add_uint(parameter_tree, hf_isup_cvr_cg_alarm_car_ind, parameter_tvb, 0, CG_CHAR_IND_LENGTH, cvr_cg_char_ind);
3306
0
  proto_tree_add_uint(parameter_tree, hf_isup_cvr_cont_chk_ind, parameter_tvb, 0, CG_CHAR_IND_LENGTH, cvr_cg_char_ind);
3307
3308
0
  proto_item_append_text(parameter_item, " : 0x%x", cvr_cg_char_ind);
3309
0
}
3310
3311
/* ------------------------------------------------------------------
3312
 Dissector Parameter nature of connection flags
3313
 */
3314
static void
3315
dissect_isup_nature_of_connection_indicators_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
3316
181
{
3317
181
  uint8_t nature_of_connection_ind;
3318
181
  static int * const isup_indicators[] = {
3319
181
    &hf_isup_satellite_indicator,
3320
181
    &hf_isup_continuity_check_indicator,
3321
181
    &hf_isup_echo_control_device_indicator,
3322
181
    NULL
3323
181
  };
3324
3325
181
  static int * const bicc_indicators[] = {
3326
181
    &hf_isup_satellite_indicator,
3327
181
    &hf_bicc_continuity_check_indicator,
3328
181
    &hf_isup_echo_control_device_indicator,
3329
181
    NULL
3330
181
  };
3331
3332
181
  nature_of_connection_ind = tvb_get_uint8(parameter_tvb, 0);
3333
181
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, NATURE_OF_CONNECTION_IND_LENGTH,
3334
181
                              g_str_equal(pinfo -> current_proto, "ISUP") ? isup_indicators : bicc_indicators, ENC_BIG_ENDIAN);
3335
3336
181
  proto_item_append_text(parameter_item, " : 0x%x", nature_of_connection_ind);
3337
181
}
3338
3339
/* ------------------------------------------------------------------
3340
 Dissector Parameter Forward Call Indicators
3341
 */
3342
static void
3343
dissect_isup_forward_call_indicators_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_item *parameter_item, proto_tree *parameter_tree)
3344
184
{
3345
184
  uint16_t forward_call_ind = tvb_get_ntohs(parameter_tvb, 0);
3346
184
  static int * const isup_indicators[] = {
3347
184
    &hf_isup_forw_call_natnl_inatnl_call_indicator,
3348
184
    &hf_isup_forw_call_end_to_end_method_indicator,
3349
184
    &hf_isup_forw_call_interworking_indicator,
3350
184
    &hf_isup_forw_call_end_to_end_info_indicator,
3351
184
    &hf_isup_forw_call_isdn_user_part_indicator,
3352
184
    &hf_isup_forw_call_preferences_indicator,
3353
184
    &hf_isup_forw_call_isdn_access_indicator,
3354
184
    &hf_isup_forw_call_sccp_method_indicator,
3355
184
    &hf_isup_forw_call_ported_num_trans_indicator,
3356
184
    &hf_isup_forw_call_qor_attempt_indicator,
3357
184
    NULL
3358
184
  };
3359
3360
184
  static int * const bicc_indicators[] = {
3361
184
    &hf_isup_forw_call_natnl_inatnl_call_indicator,
3362
184
    &hf_bicc_forw_call_end_to_end_method_indicator,
3363
184
    &hf_isup_forw_call_interworking_indicator,
3364
184
    &hf_bicc_forw_call_end_to_end_info_indicator,
3365
184
    &hf_bicc_forw_call_isdn_user_part_indicator,
3366
184
    &hf_bicc_forw_call_preferences_indicator,
3367
184
    &hf_isup_forw_call_isdn_access_indicator,
3368
184
    &hf_bicc_forw_call_sccp_method_indicator,
3369
184
    &hf_isup_forw_call_ported_num_trans_indicator,
3370
184
    &hf_isup_forw_call_qor_attempt_indicator,
3371
184
    NULL
3372
184
  };
3373
3374
184
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, FORWARD_CALL_IND_LENGTH,
3375
184
                              g_str_equal(pinfo -> current_proto, "ISUP") ? isup_indicators : bicc_indicators, ENC_BIG_ENDIAN);
3376
3377
184
  proto_item_append_text(parameter_item, " : 0x%x", forward_call_ind);
3378
184
}
3379
3380
/* ------------------------------------------------------------------
3381
 Dissector Parameter Calling Party's Category
3382
 */
3383
static void
3384
dissect_isup_calling_partys_category_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item, uint8_t itu_isup_variant)
3385
188
{
3386
188
  uint8_t calling_partys_category;
3387
3388
188
  calling_partys_category = tvb_get_uint8(parameter_tvb, 0);
3389
3390
188
  if (itu_isup_variant == ISUP_RUSSIAN_VARIANT) {
3391
0
      proto_tree_add_uint(parameter_tree, hf_russian_isup_calling_partys_category,
3392
0
                          parameter_tvb, 0, CALLING_PRTYS_CATEGORY_LENGTH, calling_partys_category);
3393
3394
0
      proto_item_append_text(parameter_item, " : 0x%x (%s)",
3395
0
          calling_partys_category,
3396
0
          val_to_str_ext_const(calling_partys_category,
3397
0
          &russian_isup_calling_partys_category_value_ext,
3398
0
          "reserved/spare"));
3399
3400
188
  } else {
3401
188
      proto_tree_add_uint(parameter_tree, hf_isup_calling_partys_category,
3402
188
                          parameter_tvb, 0, CALLING_PRTYS_CATEGORY_LENGTH, calling_partys_category);
3403
3404
188
      proto_item_append_text(parameter_item, " : 0x%x (%s)",
3405
188
                          calling_partys_category,
3406
188
                          val_to_str_ext_const(calling_partys_category,
3407
188
                                               &isup_calling_partys_category_value_ext,
3408
188
                                               "reserved/spare"));
3409
188
  }
3410
188
}
3411
3412
3413
/* ------------------------------------------------------------------
3414
  Dissector Parameter Transmission medium requirement
3415
 */
3416
static void
3417
dissect_isup_transmission_medium_requirement_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
3418
336
{
3419
336
  uint8_t transmission_medium_requirement;
3420
3421
336
  transmission_medium_requirement = tvb_get_uint8(parameter_tvb, 0);
3422
336
  proto_tree_add_uint(parameter_tree, hf_isup_transmission_medium_requirement,
3423
336
                      parameter_tvb, 0, TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH, transmission_medium_requirement);
3424
3425
336
  proto_item_append_text(parameter_item, " : %u (%s)", transmission_medium_requirement,
3426
336
                      val_to_str_ext_const(transmission_medium_requirement, &isup_transmission_medium_requirement_value_ext, "spare"));
3427
336
}
3428
3429
static char *
3430
dissect_isup_digits_common(tvbuff_t *tvb, unsigned offset, packet_info *pinfo, proto_tree *tree, proto_item *item,
3431
                           int hf_number, int hf_odd_digit, int hf_even_digit,
3432
                           bool even_indicator, e164_number_type_t number_type, unsigned nature_of_address)
3433
1.11k
{
3434
1.11k
  int            i = 0;
3435
1.11k
  int            reported_length, captured_length;
3436
1.11k
  proto_item    *digits_item;
3437
1.11k
  proto_tree    *digits_tree;
3438
1.11k
  uint8_t        digit_pair = 0;
3439
1.11k
  wmem_strbuf_t *strbuf_number;
3440
1.11k
  char          *number;
3441
1.11k
  e164_info_t    e164_info;
3442
1.11k
  int            start_offset = offset;
3443
3444
1.11k
  reported_length = tvb_reported_length_remaining(tvb, offset);
3445
1.11k
  if (reported_length == 0) {
3446
38
    expert_add_info(pinfo, item, &ei_isup_empty_number);
3447
38
    proto_item_append_text(item, ": (empty)");
3448
38
    return NULL;
3449
38
  }
3450
3451
1.07k
  strbuf_number = wmem_strbuf_new_sized(pinfo->pool, MAXDIGITS+1);
3452
3453
  /* Make the digit string, looping on captured length (in case a snaplen was set) */
3454
1.07k
  captured_length = tvb_captured_length_remaining(tvb, offset);
3455
10.8k
  while (captured_length > 0) {
3456
10.1k
    if (++i > MAXDIGITS) {
3457
301
      break;
3458
301
    }
3459
9.81k
    digit_pair = tvb_get_uint8(tvb, offset);
3460
9.81k
    wmem_strbuf_append_c(strbuf_number, number_to_char(digit_pair & ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK));
3461
3462
9.81k
    if ((captured_length - 1) > 0) {
3463
9.04k
      if (++i > MAXDIGITS) {
3464
0
        break;
3465
0
      }
3466
9.04k
      wmem_strbuf_append_c(strbuf_number, number_to_char((digit_pair & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
3467
9.04k
    }
3468
3469
9.81k
    offset += 1;
3470
9.81k
    captured_length -= 1;
3471
9.81k
  }
3472
3473
1.07k
  if  (even_indicator && (tvb_captured_length(tvb) > 0) && (++i < MAXDIGITS)) {
3474
    /* Even Indicator set -> last (even) digit is valid and has be displayed */
3475
715
    wmem_strbuf_append_c(strbuf_number, number_to_char((digit_pair & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
3476
715
  }
3477
3478
1.07k
  number = wmem_strbuf_finalize(strbuf_number);
3479
3480
  /* Now make the tree */
3481
1.07k
  offset = start_offset;
3482
1.07k
  i = 0;
3483
1.07k
  digits_item = proto_tree_add_string(tree, hf_number, tvb, offset, -1, number);
3484
1.07k
  digits_tree = proto_item_add_subtree(digits_item, ett_isup_address_digits);
3485
3486
10.8k
  while (reported_length > 0) {
3487
10.1k
    if (++i > MAXDIGITS) {
3488
301
      expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
3489
301
      break;
3490
301
    }
3491
9.82k
    proto_tree_add_item(digits_tree, hf_odd_digit, tvb, offset, 1, ENC_NA);
3492
3493
9.82k
    if ((reported_length - 1) > 0) {
3494
9.04k
      if (++i > MAXDIGITS) {
3495
0
        expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
3496
0
        break;
3497
0
      }
3498
9.04k
      proto_tree_add_item(digits_tree, hf_even_digit, tvb, offset, 1, ENC_NA);
3499
9.04k
    }
3500
3501
9.82k
    offset += 1;
3502
9.82k
    reported_length -= 1;
3503
9.82k
  }
3504
3505
1.07k
  if  (even_indicator && (tvb_reported_length(tvb) > 0)) {
3506
936
    if (++i < MAXDIGITS) {
3507
      /* Even Indicator set -> last (even) digit is valid and has be displayed */
3508
709
      proto_tree_add_item(digits_tree, hf_even_digit, tvb, offset - 1, 1, ENC_NA);
3509
709
    } else {
3510
227
      expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
3511
227
    }
3512
936
  }
3513
3514
1.07k
  if (number_type != NONE) {
3515
61
    e164_info.e164_number_type = number_type;
3516
61
    e164_info.nature_of_address = nature_of_address;
3517
61
    e164_info.E164_number_str = number;
3518
61
    e164_info.E164_number_length = i - 1;
3519
61
    dissect_e164_number(tvb, digits_tree, 2, (offset - 2), e164_info);
3520
61
  }
3521
3522
1.07k
  proto_item_append_text(item, ": %s", number);
3523
3524
1.07k
  return number;
3525
1.11k
}
3526
3527
/* ------------------------------------------------------------------
3528
  Dissector Parameter Called party number
3529
 */
3530
void
3531
dissect_isup_called_party_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
3532
348
{
3533
348
  uint8_t      indicators1, indicators2;
3534
348
  int          offset = 0;
3535
348
  int          number_plan;
3536
348
  static int * const indicators1_flags[] = {
3537
348
    &hf_isup_odd_even_indicator,
3538
348
    &hf_isup_called_party_nature_of_address_indicator,
3539
348
    NULL
3540
348
  };
3541
3542
348
  static int * const indicators2_flags[] = {
3543
348
    &hf_isup_inn_indicator,
3544
348
    &hf_isup_numbering_plan_indicator,
3545
348
    NULL
3546
348
  };
3547
3548
348
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
3549
348
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_flags, ENC_NA);
3550
348
  indicators2 = tvb_get_uint8(parameter_tvb, 1);
3551
348
  number_plan = (indicators2 & 0x70)>> 4;
3552
348
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_flags, ENC_NA);
3553
348
  offset = 2;
3554
3555
348
  tap_called_number = dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
3556
348
                             hf_isup_called, hf_isup_called_party_odd_address_signal_digit,
3557
348
                             hf_isup_called_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
3558
348
                             number_plan == 1 ? CALLED_PARTY_NUMBER : NONE,
3559
348
                             (indicators1 & 0x7f));
3560
348
}
3561
3562
/* ------------------------------------------------------------------
3563
  Dissector Parameter  Subsequent number
3564
 */
3565
static void
3566
dissect_isup_subsequent_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
3567
173
{
3568
173
  uint8_t     indicators1;
3569
173
  int         offset = 0;
3570
3571
173
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
3572
173
  proto_tree_add_boolean(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, indicators1);
3573
173
  offset = 1;
3574
3575
173
  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
3576
173
                             hf_isup_subsequent_number, hf_isup_called_party_odd_address_signal_digit,
3577
173
                             hf_isup_called_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
3578
173
                             NONE, 0);
3579
173
}
3580
/* ------------------------------------------------------------------
3581
  Dissector Parameter Information Request Indicators
3582
 */
3583
static void
3584
dissect_isup_information_request_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
3585
138
{
3586
138
  static int * const indicators[] = {
3587
138
    &hf_isup_calling_party_address_request_indicator,
3588
138
    &hf_isup_info_req_holding_indicator,
3589
138
    &hf_isup_calling_partys_category_request_indicator,
3590
138
    &hf_isup_charge_information_request_indicator,
3591
138
    &hf_isup_malicious_call_identification_request_indicator,
3592
138
    NULL
3593
138
  };
3594
3595
138
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, INFO_REQUEST_IND_LENGTH, indicators, ENC_BIG_ENDIAN);
3596
3597
138
  proto_item_append_text(parameter_item, " : 0x%x", tvb_get_ntohs(parameter_tvb, 0));
3598
138
}
3599
/* ------------------------------------------------------------------
3600
  Dissector Parameter Information Indicators
3601
 */
3602
static void
3603
dissect_isup_information_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
3604
138
{
3605
138
  static int * const indicators[] = {
3606
138
    &hf_isup_calling_party_address_response_indicator,
3607
138
    &hf_isup_hold_provided_indicator,
3608
138
    &hf_isup_calling_partys_category_response_indicator,
3609
138
    &hf_isup_charge_information_response_indicator,
3610
138
    &hf_isup_solicited_indicator,
3611
138
    NULL
3612
138
  };
3613
3614
138
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, INFO_IND_LENGTH, indicators, ENC_BIG_ENDIAN);
3615
3616
138
  proto_item_append_text(parameter_item, " : 0x%x", tvb_get_ntohs(parameter_tvb, 0));
3617
138
}
3618
/* ------------------------------------------------------------------
3619
  Dissector Parameter Continuity Indicators
3620
 */
3621
static void
3622
dissect_isup_continuity_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
3623
47
{
3624
47
  uint8_t continuity_indicators;
3625
3626
47
  continuity_indicators = tvb_get_uint8(parameter_tvb, 0);
3627
47
  proto_tree_add_boolean(parameter_tree, hf_isup_continuity_indicator, parameter_tvb, 0, CONTINUITY_IND_LENGTH,  continuity_indicators);
3628
3629
47
  proto_item_append_text(parameter_item, " : 0x%x", continuity_indicators);
3630
47
}
3631
/* ------------------------------------------------------------------
3632
 Dissector Parameter Backward Call Indicators
3633
 */
3634
static void
3635
dissect_isup_backward_call_indicators_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
3636
190
{
3637
190
  static int * const isup_indicators[] = {
3638
190
    &hf_isup_backw_call_charge_ind,
3639
190
    &hf_isup_backw_call_called_partys_status_ind,
3640
190
    &hf_isup_backw_call_called_partys_category_ind,
3641
190
    &hf_isup_backw_call_end_to_end_method_ind,
3642
190
    &hf_isup_backw_call_interworking_ind,
3643
190
    &hf_isup_backw_call_end_to_end_info_ind,
3644
190
    &hf_isup_backw_call_isdn_user_part_ind,
3645
190
    &hf_isup_backw_call_holding_ind,
3646
190
    &hf_isup_backw_call_isdn_access_ind,
3647
190
    &hf_isup_backw_call_echo_control_device_ind,
3648
190
    &hf_isup_backw_call_sccp_method_ind,
3649
190
    NULL
3650
190
  };
3651
3652
190
  static int * const bicc_indicators[] = {
3653
190
      &hf_isup_backw_call_charge_ind,
3654
190
      &hf_isup_backw_call_called_partys_status_ind,
3655
190
      &hf_isup_backw_call_called_partys_category_ind,
3656
190
      &hf_bicc_backw_call_end_to_end_method_ind,
3657
190
      &hf_isup_backw_call_interworking_ind,
3658
190
      &hf_bicc_backw_call_end_to_end_info_ind,
3659
190
      &hf_bicc_backw_call_isdn_user_part_ind,
3660
190
      &hf_isup_backw_call_holding_ind,
3661
190
      &hf_isup_backw_call_isdn_access_ind,
3662
190
      &hf_isup_backw_call_echo_control_device_ind,
3663
190
      &hf_bicc_backw_call_sccp_method_ind,
3664
190
      NULL
3665
190
  };
3666
3667
190
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, BACKWARD_CALL_IND_LENGTH,
3668
190
                              g_str_equal(pinfo -> current_proto, "ISUP") ? isup_indicators : bicc_indicators,
3669
190
                              ENC_BIG_ENDIAN);
3670
190
  proto_item_append_text(parameter_item, " : 0x%x", tvb_get_ntohs(parameter_tvb, 0));
3671
190
}
3672
3673
static void
3674
dissect_ansi_isup_backward_call_indicators_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
3675
0
{
3676
0
  static int * const isup_indicators[] = {
3677
0
    &hf_isup_backw_call_charge_ind,
3678
0
    &hf_isup_backw_call_called_partys_status_ind,
3679
0
    &hf_isup_backw_call_called_partys_category_ind,
3680
0
    &hf_isup_backw_call_end_to_end_method_ind,
3681
0
    &hf_isup_backw_call_interworking_ind,
3682
0
    &hf_isup_backw_call_iam_seg_ind,
3683
0
    &hf_isup_backw_call_isdn_user_part_ind,
3684
0
    &hf_isup_backw_call_holding_ind,
3685
0
    &hf_isup_backw_call_isdn_access_ind,
3686
0
    &hf_isup_backw_call_echo_control_device_ind,
3687
0
    &hf_isup_backw_call_sccp_method_ind,
3688
0
    NULL
3689
0
  };
3690
3691
0
  static int * const bicc_indicators[] = {
3692
0
      &hf_isup_backw_call_charge_ind,
3693
0
      &hf_isup_backw_call_called_partys_status_ind,
3694
0
      &hf_isup_backw_call_called_partys_category_ind,
3695
0
      &hf_bicc_backw_call_end_to_end_method_ind,
3696
0
      &hf_isup_backw_call_interworking_ind,
3697
0
      &hf_isup_backw_call_iam_seg_ind,
3698
0
      &hf_bicc_backw_call_isdn_user_part_ind,
3699
0
      &hf_isup_backw_call_holding_ind,
3700
0
      &hf_isup_backw_call_isdn_access_ind,
3701
0
      &hf_isup_backw_call_echo_control_device_ind,
3702
0
      &hf_bicc_backw_call_sccp_method_ind,
3703
0
      NULL
3704
0
  };
3705
3706
0
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, BACKWARD_CALL_IND_LENGTH,
3707
0
                              g_str_equal(pinfo -> current_proto, "ISUP") ? isup_indicators : bicc_indicators, ENC_BIG_ENDIAN);
3708
0
  proto_item_append_text(parameter_item, " : 0x%x", tvb_get_ntohs(parameter_tvb, 0));
3709
0
}
3710
/* ------------------------------------------------------------------
3711
  Dissector Parameter Cause Indicators - no detailed dissection since defined in Rec. Q.850
3712
 */
3713
3714
/*
3715
 * Cause codes for Cause.
3716
 * The decoding of cause indicators parameter field are defined in ITU-T
3717
 * Recommendation Q.850; those are different from the ones in the Q.931
3718
 * dissector, as that has some values not specified by the standard but
3719
 * that appear to be used for purposes other than the ones in Q.850.
3720
 */
3721
  /* The table is "filled" with "unassigned" to make full use of value_string_ext */
3722
static const value_string q850_cause_code_vals[] = {
3723
  { 0x00,  "Valid cause code not yet received" },
3724
  { 0x01,  "Unallocated (unassigned) number" },
3725
  { 0x02,  "No route to specified transit network" },
3726
  { 0x03,  "No route to destination" },
3727
  { 0x04,  "Send special information tone" },
3728
  { 0x05,  "Misdialled trunk prefix" },
3729
  { 0x06,  "Channel unacceptable" },
3730
  { 0x07,  "Call awarded and being delivered in an established channel" },
3731
  { 0x08,  "Preemption" },
3732
  { 0x09,  "Preemption - circuit reserved for reuse" },
3733
  { 0x0A,  "Unassigned" },
3734
  { 0x0B,  "Unassigned" },
3735
  { 0x0C,  "Unassigned" },
3736
  { 0x0D,  "Unassigned" },
3737
  { 0x0E,  "QoR: ported number" },
3738
  { 0x0F,  "Unassigned" },
3739
  { 0x10,  "Normal call clearing" },
3740
  { 0x11,  "User busy" },
3741
  { 0x12,  "No user responding" },
3742
  { 0x13,  "No answer from user (user alerted)" },
3743
  { 0x14,  "Subscriber absent" },
3744
  { 0x15,  "Call rejected" },
3745
  { 0x16,  "Number changed" },
3746
  { 0x17,  "Redirection to new destination" },
3747
  { 0x18,  "Call rejected due to feature at the destination" },
3748
  { 0x19,  "Exchange routing error" },
3749
  { 0x1A,  "Non-selected user clearing" },
3750
  { 0x1B,  "Destination out of order" },
3751
  { 0x1C,  "Invalid number format (address incomplete)" },
3752
  { 0x1D,  "Facility rejected" },
3753
  { 0x1E,  "Response to STATUS ENQUIRY" },
3754
  { 0x1F,  "Normal unspecified" },
3755
  { 0x20,  "Unassigned" },
3756
  { 0x21,  "Circuit out of order" },
3757
  { 0x22,  "No circuit/channel available" },
3758
  { 0x23,  "Unassigned" },
3759
  { 0x24,  "Unassigned" },
3760
  { 0x25,  "Unassigned" },
3761
  { 0x26,  "Network out of order" },
3762
  { 0x27,  "Permanent frame mode connection out of service" },
3763
  { 0x28,  "Permanent frame mode connection operational" },
3764
  { 0x29,  "Temporary failure" },
3765
  { 0x2A,  "Switching equipment congestion" },
3766
  { 0x2B,  "Access information discarded" },
3767
  { 0x2C,  "Requested circuit/channel not available" },
3768
  { 0x2D,  "Unassigned" },
3769
  { 0x2E,  "Precedence call blocked" },
3770
  { 0x2F,  "Resources unavailable, unspecified" },
3771
  { 0x30,  "Unassigned" },
3772
  { 0x31,  "Quality of service unavailable" },
3773
  { 0x32,  "Requested facility not subscribed" },
3774
  { 0x33,  "Unassigned" },
3775
  { 0x34,  "Unassigned" },
3776
  { 0x35,  "Outgoing calls barred within CUG" },
3777
  { 0x36,  "Unassigned" },
3778
  { 0x37,  "Incoming calls barred within CUG" },
3779
  { 0x38,  "Call waiting not subscribed" },
3780
  { 0x39,  "Bearer capability not authorized" },
3781
  { 0x3A,  "Bearer capability not presently available" },
3782
  { 0x3B,  "Unassigned" },
3783
  { 0x3C,  "Unassigned" },
3784
  { 0x3D,  "Unassigned" },
3785
  { 0x3E,  "Inconsistency in designated outgoing access information and subscriber class" },
3786
  { 0x3F,  "Service or option not available, unspecified" },
3787
  { 0x40,  "Unassigned" },
3788
  { 0x41,  "Bearer capability not implemented" },
3789
  { 0x42,  "Channel type not implemented" },
3790
  { 0x43,  "Unassigned" },
3791
  { 0x44,  "Unassigned" },
3792
  { 0x45,  "Requested facility not implemented" },
3793
  { 0x46,  "Only restricted digital information bearer capability is available" },
3794
  { 0x47,  "Unassigned" },
3795
  { 0x48,  "Unassigned" },
3796
  { 0x49,  "Unassigned" },
3797
  { 0x4A,  "Unassigned" },
3798
  { 0x4B,  "Unassigned" },
3799
  { 0x4C,  "Unassigned" },
3800
  { 0x4D,  "Unassigned" },
3801
  { 0x4E,  "Unassigned" },
3802
  { 0x4F,  "Service or option not implemented, unspecified" },
3803
  { 0x50,  "Unassigned" },
3804
  { 0x51,  "Invalid call reference value" },
3805
  { 0x52,  "Identified channel does not exist" },
3806
  { 0x53,  "Call identity does not exist for suspended call" },
3807
  { 0x54,  "Call identity in use" },
3808
  { 0x55,  "No call suspended" },
3809
  { 0x56,  "Call having the requested call identity has been cleared" },
3810
  { 0x57,  "Called user not member of CUG" },
3811
  { 0x58,  "Incompatible destination" },
3812
  { 0x59,  "Unassigned" },
3813
  { 0x5A,  "Non-existing CUG" },
3814
  { 0x5B,  "Invalid transit network selection (national use)" },
3815
  { 0x5C,  "Unassigned" },
3816
  { 0x5D,  "Unassigned" },
3817
  { 0x5E,  "Unassigned" },
3818
  { 0x5F,  "Invalid message, unspecified" },
3819
  { 0x60,  "Mandatory information element is missing" },
3820
  { 0x61,  "Message type non-existent or not implemented" },
3821
  { 0x62,  "Message not compatible with call state or message type non-existent or not implemented" },
3822
  { 0x63,  "Information element nonexistent or not implemented" },
3823
  { 0x64,  "Invalid information element contents" },
3824
  { 0x65,  "Message not compatible with call state" },
3825
  { 0x66,  "Recovery on timer expiry" },
3826
  { 0x67,  "Parameter non-existent or not implemented - passed on" },
3827
  { 0x68,  "Unassigned" },
3828
  { 0x69,  "Unassigned" },
3829
  { 0x6A,  "Unassigned" },
3830
  { 0x6B,  "Unassigned" },
3831
  { 0x6C,  "Unassigned" },
3832
  { 0x6D,  "Unassigned" },
3833
  { 0x6E,  "Message with unrecognized parameter discarded" },
3834
  { 0x6F,  "Protocol error, unspecified" },
3835
  { 0x70,  "Unassigned" },
3836
  { 0x71,  "Unassigned" },
3837
  { 0x72,  "Unassigned" },
3838
  { 0x73,  "Unassigned" },
3839
  { 0x74,  "Unassigned" },
3840
  { 0x75,  "Unassigned" },
3841
  { 0x76,  "Unassigned" },
3842
  { 0x77,  "Unassigned" },
3843
  { 0x78,  "Unassigned" },
3844
  { 0x79,  "Unassigned" },
3845
  { 0x7A,  "Unassigned" },
3846
  { 0x7B,  "Unassigned" },
3847
  { 0x7C,  "Unassigned" },
3848
  { 0x7D,  "Unassigned" },
3849
  { 0x7E,  "Unassigned" },
3850
  { 0x7F,  "Interworking, unspecified" },
3851
  { 0,  NULL }
3852
};
3853
value_string_ext q850_cause_code_vals_ext = VALUE_STRING_EXT_INIT(q850_cause_code_vals);
3854
3855
static const value_string ansi_isup_cause_code_vals[] = {
3856
  { 0x00,  "Valid cause code not yet received" },
3857
  { 0x01,  "Unallocated (unassigned) number" },
3858
  { 0x02,  "No route to specified transit network" },
3859
  { 0x03,  "No route to destination" },
3860
  { 0x04,  "Send special information tone" },
3861
  { 0x05,  "Misdialled trunk prefix" },
3862
  { 0x06,  "Channel unacceptable" },
3863
  { 0x07,  "Call awarded and being delivered in an established channel" },
3864
  { 0x08,  "Preemption" },
3865
  { 0x09,  "Preemption - circuit reserved for reuse" },
3866
  { 0x0A,  "Unassigned" },
3867
  { 0x0B,  "Unassigned" },
3868
  { 0x0C,  "Unassigned" },
3869
  { 0x0D,  "Unassigned" },
3870
  { 0x0E,  "QoR: ported number" },
3871
  { 0x0F,  "Unassigned" },
3872
  { 0x10,  "Normal call clearing" },
3873
  { 0x11,  "User busy" },
3874
  { 0x12,  "No user responding" },
3875
  { 0x13,  "No answer from user (user alerted)" },
3876
  { 0x14,  "Subscriber absent" },
3877
  { 0x15,  "Call rejected" },
3878
  { 0x16,  "Number changed" },
3879
  { 0x17,  "Unallocated destination number" },
3880
  { 0X18,  "Undefined business group" },
3881
  { 0x19,  "Exchange routing error" },
3882
  { 0x1A,  "Non-selected user clearing" },
3883
  { 0x1B,  "Destination out of order" },
3884
  { 0x1C,  "Invalid number format (address incomplete)" },
3885
  { 0x1D,  "Facility rejected" },
3886
  { 0x1E,  "Response to STATUS ENQUIRY" },
3887
  { 0x1F,  "Normal unspecified" },
3888
  { 0x20,  "Unassigned" },
3889
  { 0x21,  "Circuit out of order" },
3890
  { 0x22,  "No circuit/channel available" },
3891
  { 0x23,  "Unassigned" },
3892
  { 0x24,  "Unassigned" },
3893
  { 0x25,  "Unassigned" },
3894
  { 0x26,  "Network out of order" },
3895
  { 0x27,  "Permanent frame mode connection out of service" },
3896
  { 0x28,  "Permanent frame mode connection operational" },
3897
  { 0x29,  "Temporary failure" },
3898
  { 0x2A,  "Switching equipment congestion" },
3899
  { 0x2B,  "Access information discarded" },
3900
  { 0x2C,  "Requested circuit/channel not available" },
3901
  { 0x2D,  "Preemption" },
3902
  { 0x2E,  "Precedence call blocked" },
3903
  { 0x2F,  "Resources unavailable, unspecified" },
3904
  { 0x30,  "Unassigned" },
3905
  { 0x31,  "Quality of service unavailable" },
3906
  { 0x32,  "Requested facility not subscribed" },
3907
  { 0x33,  "Call type incompatible with service request" },
3908
  { 0x34,  "Unassigned" },
3909
  { 0x35,  "Outgoing calls barred within CUG" },
3910
  { 0x36,  "Call blocked due to group restriction" },
3911
  { 0x37,  "Incoming calls barred within CUG" },
3912
  { 0x38,  "Call waiting not subscribed" },
3913
  { 0x39,  "Bearer capability not authorized" },
3914
  { 0x3A,  "Bearer capability not presently available" },
3915
  { 0x3B,  "Unassigned" },
3916
  { 0x3C,  "Unassigned" },
3917
  { 0x3D,  "Unassigned" },
3918
  { 0x3E,  "Inconsistency in designated outgoing access information and subscriber class" },
3919
  { 0x3F,  "Service or option not available, unspecified" },
3920
  { 0x40,  "Unassigned" },
3921
  { 0x41,  "Bearer capability not implemented" },
3922
  { 0x42,  "Channel type not implemented" },
3923
  { 0x43,  "Unassigned" },
3924
  { 0x44,  "Unassigned" },
3925
  { 0x45,  "Requested facility not implemented" },
3926
  { 0x46,  "Only restricted digital information bearer capability is available" },
3927
  { 0x47,  "Unassigned" },
3928
  { 0x48,  "Unassigned" },
3929
  { 0x49,  "Unassigned" },
3930
  { 0x4A,  "Unassigned" },
3931
  { 0x4B,  "Unassigned" },
3932
  { 0x4C,  "Unassigned" },
3933
  { 0x4D,  "Unassigned" },
3934
  { 0x4E,  "Unassigned" },
3935
  { 0x4F,  "Service or option not implemented, unspecified" },
3936
  { 0x50,  "Unassigned" },
3937
  { 0x51,  "Invalid call reference value" },
3938
  { 0x52,  "Identified channel does not exist" },
3939
  { 0x53,  "Call identity does not exist for suspended call" },
3940
  { 0x54,  "Call identity in use" },
3941
  { 0x55,  "No call suspended" },
3942
  { 0x56,  "Call having the requested call identity has been cleared" },
3943
  { 0x57,  "Called user not member of CUG" },
3944
  { 0x58,  "Incompatible destination" },
3945
  { 0x59,  "Unassigned" },
3946
  { 0x5A,  "Non-existing CUG" },
3947
  { 0x5B,  "Invalid transit network selection (national use)" },
3948
  { 0x5C,  "Unassigned" },
3949
  { 0x5D,  "Unassigned" },
3950
  { 0x5E,  "Unassigned" },
3951
  { 0x5F,  "Invalid message, unspecified" },
3952
  { 0x60,  "Mandatory information element is missing" },
3953
  { 0x61,  "Message type non-existent or not implemented" },
3954
  { 0x62,  "Message not compatible with call state or message type non-existent or not implemented" },
3955
  { 0x63,  "Information element nonexistent or not implemented" },
3956
  { 0x64,  "Invalid information element contents" },
3957
  { 0x65,  "Message not compatible with call state" },
3958
  { 0x66,  "Recovery on timer expiry" },
3959
  { 0x67,  "Parameter non-existent or not implemented - passed on" },
3960
  { 0x68,  "Unassigned" },
3961
  { 0x69,  "Unassigned" },
3962
  { 0x6A,  "Unassigned" },
3963
  { 0x6B,  "Unassigned" },
3964
  { 0x6C,  "Unassigned" },
3965
  { 0x6D,  "Unassigned" },
3966
  { 0x6E,  "Message with unrecognized parameter discarded" },
3967
  { 0x6F,  "Protocol error, unspecified" },
3968
  { 0x70,  "Unassigned" },
3969
  { 0x71,  "Unassigned" },
3970
  { 0x72,  "Unassigned" },
3971
  { 0x73,  "Unassigned" },
3972
  { 0x74,  "Unassigned" },
3973
  { 0x75,  "Unassigned" },
3974
  { 0x76,  "Unassigned" },
3975
  { 0x77,  "Unassigned" },
3976
  { 0x78,  "Unassigned" },
3977
  { 0x79,  "Unassigned" },
3978
  { 0x7A,  "Unassigned" },
3979
  { 0x7B,  "Unassigned" },
3980
  { 0x7C,  "Unassigned" },
3981
  { 0x7D,  "Unassigned" },
3982
  { 0x7E,  "Unassigned" },
3983
  { 0x7F,  "Internetworking, unspecified" },
3984
  { 0,  NULL }
3985
};
3986
static value_string_ext ansi_isup_cause_code_vals_ext = VALUE_STRING_EXT_INIT(ansi_isup_cause_code_vals);
3987
3988
static const value_string ansi_isup_coding_standard_vals[] = {
3989
  { 0, "CCITT Standard" },
3990
  { 1, "Reserved for other international standards" },
3991
  { 2, "ANSI Standard" },
3992
  { 3, "Reserved" },
3993
  { 0,  NULL }
3994
};
3995
void
3996
dissect_isup_cause_indicators_parameter(tvbuff_t *parameter_tvb, packet_info* pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
3997
124
{ unsigned length = tvb_reported_length(parameter_tvb);
3998
124
  proto_tree_add_item(parameter_tree, hf_isup_cause_indicators, parameter_tvb, 0, -1, ENC_NA);
3999
124
  dissect_q931_cause_ie(parameter_tvb, pinfo, 0, length,
4000
124
                        parameter_tree,
4001
124
                        hf_isup_cause_indicator, &tap_cause_value, isup_parameter_type_value);
4002
124
}
4003
4004
static void
4005
dissect_ansi_isup_cause_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
4006
0
{
4007
0
  uint8_t coding_standard;
4008
0
  uint8_t cause_value;
4009
0
  unsigned offset = 0;
4010
0
  unsigned length = tvb_reported_length(parameter_tvb);
4011
4012
0
  coding_standard = (tvb_get_uint8(parameter_tvb, offset)&0x60)>>5;
4013
4014
0
  switch (coding_standard) {
4015
0
    case 0:
4016
      /*CCITT*/
4017
0
      proto_tree_add_item(parameter_tree, hf_isup_cause_location, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4018
0
      proto_tree_add_item(parameter_tree, hf_ansi_isup_coding_standard, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4019
0
      proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4020
0
      offset += 1;
4021
0
      length -= 1;
4022
0
      if (length == 0)
4023
0
        return;
4024
0
      proto_tree_add_item(parameter_tree, hf_isup_cause_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4025
0
      cause_value = tvb_get_uint8(parameter_tvb, offset)&0x7f;
4026
0
      offset += 1;
4027
0
      length -= 1;
4028
0
      proto_item_append_text(parameter_item, " : %s (%u)",
4029
0
                          val_to_str_ext_const(cause_value, &q850_cause_code_vals_ext, "spare"), cause_value);
4030
0
      if (length == 0) {
4031
0
        return;
4032
0
      }
4033
0
      proto_tree_add_item(parameter_tree, hf_isup_diagnostic, parameter_tvb, offset, length, ENC_NA);
4034
0
      return;
4035
0
    case 2:
4036
      /*ANSI*/
4037
0
      proto_tree_add_item(parameter_tree, hf_isup_cause_location, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4038
0
      proto_tree_add_item(parameter_tree, hf_ansi_isup_coding_standard, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4039
0
      proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4040
0
      offset += 1;
4041
0
      length -= 1;
4042
0
      if (length == 0)
4043
0
        return;
4044
0
      proto_tree_add_item(parameter_tree, hf_ansi_isup_cause_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4045
0
      cause_value = tvb_get_uint8(parameter_tvb, offset)&0x7f;
4046
0
      proto_item_append_text(parameter_item, " : %s (%u)",
4047
0
                          val_to_str_ext_const(cause_value, &ansi_isup_cause_code_vals_ext, "spare"),
4048
0
                          cause_value);
4049
0
      offset += 1;
4050
0
      length -= 1;
4051
0
      if (length == 0) {
4052
0
        return;
4053
0
      }
4054
0
      proto_tree_add_item(parameter_tree, hf_isup_diagnostic, parameter_tvb, offset, length, ENC_NA);
4055
0
      return;
4056
0
    default:
4057
0
      proto_tree_add_item(parameter_tree, hf_ansi_isup_coding_standard, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4058
0
      proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4059
0
      break;
4060
0
  }
4061
0
}
4062
4063
/* ------------------------------------------------------------------
4064
  Dissector ANSI Transit network selection
4065
 */
4066
4067
static const value_string ansi_isup_tns_nw_id_plan_vals[] = {
4068
    { 0x00, "Unknown" },
4069
    { 0x01, "3-digit carrier id with circuit code" },
4070
    { 0x02, "4-digit carrier id with circuit code" },
4071
    {    0, NULL } };
4072
4073
static void
4074
dissect_ansi_isup_transit_network_selection_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo _U_, proto_tree *parameter_tree, proto_item *parameter_item _U_)
4075
0
{
4076
0
  int         offset = 0;
4077
4078
0
  static int * const indicators_fields[] = {
4079
0
    &hf_ansi_isup_spare_b7,
4080
0
    &hf_isup_type_of_network_identification,
4081
0
    &hf_ansi_isup_tns_nw_id_plan,
4082
0
    NULL
4083
0
  };
4084
4085
0
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators_fields, ENC_NA);
4086
0
  offset = 1;
4087
4088
0
  proto_tree_add_item(parameter_tree, hf_ansi_isup_nw_id, parameter_tvb, offset, 2, ENC_BCD_DIGITS_0_9|ENC_LITTLE_ENDIAN);
4089
0
  offset += 2;
4090
0
  proto_tree_add_item(parameter_tree, hf_ansi_isup_circuit_code, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4091
4092
0
}
4093
4094
static const value_string ansi_isup_type_of_nw_id_vals[] = {
4095
    { 0x00, "Spare" },
4096
    { 0x01, "Spare" },
4097
    { 0x02, "National network identification" },
4098
    { 0x03, "Spare" },
4099
    { 0x04, "Spare" },
4100
    { 0x05, "Spare" },
4101
    { 0x06, "Spare" },
4102
    { 0x07, "Spare" },
4103
    {    0, NULL } };
4104
4105
static const value_string ansi_isup_nw_id_plan_vals[] = {
4106
    { 0x00, "Unknown" },
4107
    { 0x01, "3-digit carrier id" },
4108
    { 0x02, "4-digit carrier id" },
4109
    {    0, NULL } };
4110
4111
static void
4112
dissect_ansi_isup_param_carrier_id(tvbuff_t *parameter_tvb, packet_info *pinfo _U_, proto_tree *parameter_tree, proto_item *parameter_item _U_)
4113
0
{
4114
0
  unsigned offset = 0;
4115
4116
0
  static int * const flags[] = {
4117
0
    &hf_ansi_isup_spare_b7,
4118
0
    &hf_ansi_isup_type_of_nw_id,
4119
0
    &hf_ansi_isup_nw_id_plan,
4120
0
    NULL
4121
0
  };
4122
4123
0
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, offset, 1, flags, ENC_BIG_ENDIAN);
4124
0
  offset++;
4125
4126
0
  proto_tree_add_item(parameter_tree, hf_ansi_isup_nw_id, parameter_tvb, offset, 2, ENC_BCD_DIGITS_0_9|ENC_LITTLE_ENDIAN);
4127
4128
0
}
4129
4130
/* ------------------------------------------------------------------
4131
  Dissector Parameter Suspend/Resume Indicators
4132
 */
4133
static void
4134
dissect_isup_suspend_resume_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
4135
80
{
4136
80
  uint8_t indicators;
4137
4138
80
  indicators = tvb_get_uint8(parameter_tvb, 0);
4139
80
  proto_tree_add_boolean(parameter_tree, hf_isup_suspend_resume_indicator, parameter_tvb, 0, SUSPEND_RESUME_IND_LENGTH,  indicators);
4140
4141
80
  proto_item_append_text(parameter_item, " : 0x%x", indicators);
4142
80
}
4143
/* ------------------------------------------------------------------
4144
  Dissector Parameter Range and Status Indicators
4145
 */
4146
static void
4147
dissect_isup_range_and_status_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
4148
58
{
4149
58
  proto_tree *range_tree;
4150
58
  unsigned offset = 0;
4151
58
  uint8_t range, actual_status_length;
4152
4153
58
  range = tvb_get_uint8(parameter_tvb, 0) + 1;
4154
58
  proto_tree_add_uint_format(parameter_tree, hf_isup_range_indicator, parameter_tvb, offset, RANGE_LENGTH, range, "Range: %u", range);
4155
58
  offset = offset + RANGE_LENGTH;
4156
4157
58
  actual_status_length = tvb_reported_length_remaining(parameter_tvb, offset);
4158
58
  if (actual_status_length > 0) {
4159
51
    range_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1, ett_isup_range, NULL, "Status subfield");
4160
51
    if (range<9) {
4161
7
      proto_tree_add_uint_bits_format_value(range_tree, hf_isup_bitbucket, parameter_tvb, (offset*8)+(8-range), range,
4162
7
                          tvb_get_uint8(parameter_tvb, offset), ENC_BIG_ENDIAN, "%u bit 1", range);
4163
7
    }
4164
51
  } else {
4165
7
    expert_add_info(pinfo, parameter_item, &ei_isup_status_subfield_not_present);
4166
7
  }
4167
4168
58
  proto_item_append_text(parameter_item, ": Range (%u) and status", range);
4169
58
}
4170
/* ------------------------------------------------------------------
4171
  Dissector Parameter Circuit group supervision message type
4172
 */
4173
static void
4174
dissect_isup_circuit_group_supervision_message_type_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
4175
51
{
4176
51
  uint8_t cgs_message_type;
4177
4178
51
  cgs_message_type = tvb_get_uint8(parameter_tvb, 0);
4179
51
  proto_tree_add_uint(parameter_tree, hf_isup_cgs_message_type, parameter_tvb, 0, CIRC_GRP_SV_MSG_TYPE_LENGTH, cgs_message_type);
4180
4181
51
  proto_item_append_text(parameter_item, " : %s (%u)",
4182
51
                      val_to_str_const(cgs_message_type, isup_cgs_message_type_value, "unknown"), cgs_message_type);
4183
51
}
4184
/* ------------------------------------------------------------------
4185
  Dissector Parameter Facility indicator parameter
4186
 */
4187
static void
4188
dissect_isup_facility_ind_parameter(tvbuff_t *parameter_tvb, proto_item *parameter_item)
4189
83
{
4190
83
  uint8_t indicator;
4191
4192
83
  indicator = tvb_get_uint8(parameter_tvb, 0);
4193
4194
83
  proto_item_append_text(parameter_item, " : %s (%u)"  , val_to_str_const(indicator, isup_facility_ind_value, "spare"), indicator);
4195
83
}
4196
/* ------------------------------------------------------------------
4197
  Dissector Parameter Circuit state indicator
4198
 */
4199
static void
4200
dissect_isup_circuit_state_ind_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
4201
84
{
4202
84
  proto_item *circuit_state_item;
4203
84
  proto_tree *circuit_state_tree;
4204
84
  uint8_t     circuit_state;
4205
84
  int         offset = 0;
4206
84
  int         i      = 0;
4207
4208
3.88k
  while (tvb_reported_length_remaining(parameter_tvb, offset) > 0) {
4209
3.79k
    circuit_state_tree = proto_tree_add_subtree_format(parameter_tree, parameter_tvb, offset, -1,
4210
3.79k
                                             ett_isup_circuit_state_ind, &circuit_state_item,
4211
3.79k
                                             "Circuit# CIC+%u state", i);
4212
3.79k
    circuit_state = tvb_get_uint8(parameter_tvb, offset);
4213
3.79k
    if ((circuit_state & DC_8BIT_MASK) == 0) {
4214
1.21k
      proto_tree_add_uint(circuit_state_tree, hf_isup_mtc_blocking_state1, parameter_tvb, offset, 1, circuit_state);
4215
1.21k
      proto_item_append_text(circuit_state_item, ": %s",
4216
1.21k
                          val_to_str_const(circuit_state&BA_8BIT_MASK, isup_mtc_blocking_state_DC00_value, "unknown"));
4217
1.21k
    }
4218
2.58k
    else {
4219
2.58k
      proto_tree_add_uint(circuit_state_tree, hf_isup_mtc_blocking_state2, parameter_tvb, offset, 1, circuit_state);
4220
2.58k
      proto_tree_add_uint(circuit_state_tree, hf_isup_call_proc_state, parameter_tvb, offset, 1, circuit_state);
4221
2.58k
      proto_tree_add_uint(circuit_state_tree, hf_isup_hw_blocking_state, parameter_tvb, offset, 1, circuit_state);
4222
2.58k
      proto_item_append_text(circuit_state_item, ": %s", val_to_str_const(circuit_state&BA_8BIT_MASK, isup_mtc_blocking_state_DCnot00_value, "unknown"));
4223
2.58k
    }
4224
3.79k
    i++;
4225
3.79k
    offset += 1;
4226
3.79k
  }
4227
84
  proto_item_append_text(parameter_item, " (national use)");
4228
84
}
4229
/* ------------------------------------------------------------------
4230
  Dissector Parameter Event information
4231
 */
4232
static void
4233
dissect_isup_event_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
4234
35
{
4235
35
  uint8_t indicators;
4236
4237
35
  indicators = tvb_get_uint8(parameter_tvb, 0);
4238
35
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_event_ind, parameter_tvb, 0, EVENT_INFO_LENGTH, indicators,
4239
35
                             "%s (%u)",
4240
35
                             val_to_str_const(indicators & GFEDCBA_8BIT_MASK, isup_event_ind_value, "spare"),
4241
35
                             indicators & GFEDCBA_8BIT_MASK);
4242
35
  proto_tree_add_boolean(parameter_tree, hf_isup_event_presentation_restricted_ind, parameter_tvb, 0, EVENT_INFO_LENGTH, indicators);
4243
4244
35
  proto_item_append_text(parameter_item, " : %s (%u)", val_to_str_const(indicators & GFEDCBA_8BIT_MASK, isup_event_ind_value, "spare"), indicators);
4245
35
}
4246
/* ------------------------------------------------------------------
4247
  Dissector Parameter User-to-user information- no detailed dissection since defined in Rec. Q.931
4248
 */
4249
static void
4250
dissect_isup_user_to_user_information_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
4251
51
{ unsigned length = tvb_reported_length(parameter_tvb);
4252
51
  proto_tree_add_item(parameter_tree, hf_isup_user_to_user_info, parameter_tvb, 0, -1, ENC_NA);
4253
51
  dissect_q931_user_user_ie(parameter_tvb, pinfo, 0, length,
4254
51
    parameter_tree);
4255
51
}
4256
/* ------------------------------------------------------------------
4257
  Dissector Parameter Call Reference
4258
 */
4259
static void
4260
dissect_isup_call_reference_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
4261
39
{
4262
39
  uint32_t call_id;
4263
39
  uint16_t spc;
4264
4265
39
  call_id = tvb_get_ntoh24(parameter_tvb, 0);
4266
39
  spc = tvb_get_letohs(parameter_tvb, CALL_ID_LENGTH) & 0x3FFF; /*since 1st 2 bits spare */
4267
39
  proto_tree_add_item(parameter_tree, hf_isup_call_identity, parameter_tvb, 0, CALL_ID_LENGTH, ENC_BIG_ENDIAN);
4268
39
  proto_tree_add_item(parameter_tree, hf_isup_signalling_point_code, parameter_tvb, CALL_ID_LENGTH, SPC_LENGTH, ENC_BIG_ENDIAN);
4269
4270
39
  proto_item_append_text(parameter_item, " : Call ID = %u, SPC = %u", call_id, spc);
4271
39
}
4272
/* ------------------------------------------------------------------
4273
  Dissector Parameter Access Transport - no detailed dissection since defined in Rec. Q.931
4274
 */
4275
static void
4276
dissect_isup_access_transport_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree,
4277
                                        proto_item *parameter_item _U_, packet_info *pinfo)
4278
85
{
4279
4280
85
  proto_tree_add_item(parameter_tree, hf_isup_access_transport_parameter_field, parameter_tvb, 0, -1, ENC_NA);
4281
4282
85
  if (q931_ie_handle)
4283
85
    call_dissector(q931_ie_handle, parameter_tvb, pinfo, parameter_tree);
4284
85
}
4285
4286
/* dissect x.213 NSAP coded Address */
4287
4288
static const value_string x213_afi_value[] = {
4289
  { NSAP_IDI_IANA_ICP_DEC,              "IANA ICP, decimal"},
4290
  { NSAP_IDI_IANA_ICP_BIN,              "IANA ICP, binary"},
4291
  { NSAP_IDI_X_121_DEC_FSD_NZ,          "X.121, decimal, first significant digit non-zero"},
4292
  { NSAP_IDI_X_121_BIN_FSD_NZ,          "X.121, binary, first significant digit non-zero"},
4293
  { NSAP_IDI_ISO_DCC_DEC,               "ISO DCC, decimal"},
4294
  { NSAP_IDI_ISO_DCC_BIN,               "ISO DCC, binary"},
4295
  { NSAP_IDI_F_69_DEC_FSD_NZ,           "F.69, decimal, first significant digit non-zero"},
4296
  { NSAP_IDI_F_69_BIN_FSD_NZ,           "F.69, binary, first significant digit non-zero"},
4297
  { NSAP_IDI_E_163_DEC_FSD_NZ,          "E.163, decimal, first significant digit non-zero"},
4298
  { NSAP_IDI_E_163_BIN_FSD_NZ,          "E.163, binary, first significant digit non-zero"},
4299
  { NSAP_IDI_E_164_DEC_FSD_NZ,          "E.164, decimal, first significant digit non-zero"},
4300
  { NSAP_IDI_E_164_BIN_FSD_NZ,          "E.164, binary, first significant digit non-zero"},
4301
  { NSAP_IDI_ISO_6523_ICD_DEC,          "ISO 6523-ICD, decimal"},
4302
  { NSAP_IDI_ISO_6523_ICD_BIN,          "ISO 6523-ICD, binary"},
4303
  { NSAP_IDI_LOCAL_DEC,                 "Local, decimal"},
4304
  { NSAP_IDI_LOCAL_BIN,                 "Local, binary"},
4305
  { NSAP_IDI_LOCAL_ISO_646_CHAR,        "Local, ISO/IEC 646 character"},
4306
  { NSAP_IDI_LOCAL_NATIONAL_CHAR,       "Local, National character"},
4307
  { NSAP_IDI_X_121_DEC_FSD_Z,           "X.121, decimal, first significant digit zero"},
4308
  { NSAP_IDI_X_121_BIN_FSD_Z,           "X.121, binary, first significant digit zero"},
4309
  { NSAP_IDI_F_69_DEC_FSD_Z,            "F.69, decimal, first significant digit zero"},
4310
  { NSAP_IDI_F_69_BIN_FSD_Z,            "F.69, binary, first significant digit zero"},
4311
  { NSAP_IDI_E_163_DEC_FSD_Z,           "E.163, decimal, first significant digit zero"},
4312
  { NSAP_IDI_E_163_BIN_FSD_Z,           "E.163, binary, first significant digit zero"},
4313
  { NSAP_IDI_E_164_DEC_FSD_Z,           "E.164, decimal, first significant digit zero"},
4314
  { NSAP_IDI_E_164_BIN_FSD_Z,           "E.164, binary, first significant digit zero"},
4315
4316
  { NSAP_IDI_ITU_T_IND_DEC,             "ITU-T IND, decimal"},
4317
  { NSAP_IDI_ITU_T_IND_BIN,             "ITU-T IND, binary"},
4318
4319
  { NSAP_IDI_IANA_ICP_DEC_GROUP,        "IANA ICP Group no, decimal"},
4320
  { NSAP_IDI_IANA_ICP_BIN_GROUP,        "IANA ICP Group no, binary"},
4321
  { NSAP_IDI_X_121_DEC_FSD_NZ_GROUP,    "X.121 Group no, decimal, first significant digit non-zero"},
4322
  { NSAP_IDI_X_121_BIN_FSD_NZ_GROUP,    "X.121 Group no, binary, first significant digit non-zero"},
4323
  { NSAP_IDI_ISO_DCC_DEC_GROUP,         "ISO DCC Group no, decimal"},
4324
  { NSAP_IDI_ISO_DCC_BIN_GROUP,         "ISO DCC Group no, binary"},
4325
  { NSAP_IDI_F_69_DEC_FSD_NZ_GROUP,     "F.69 Group no, decimal, first significant digit non-zero"},
4326
  { NSAP_IDI_F_69_BIN_FSD_NZ_GROUP,     "F.69 Group no, binary, first significant digit non-zero"},
4327
  { NSAP_IDI_E_163_DEC_FSD_NZ_GROUP,    "E.163 Group no, decimal, first significant digit non-zero"},
4328
  { NSAP_IDI_E_163_BIN_FSD_NZ_GROUP,    "E.163 Group no, binary, first significant digit non-zero"},
4329
  { NSAP_IDI_E_164_DEC_FSD_NZ_GROUP,    "E.164 Group no, decimal, first significant digit non-zero"},
4330
  { NSAP_IDI_E_164_BIN_FSD_NZ_GROUP,    "E.164 Group no, binary, first significant digit non-zero"},
4331
  { NSAP_IDI_ISO_6523_ICD_DEC_GROUP,    "ISO 6523-ICD Group no, decimal"},
4332
  { NSAP_IDI_ISO_6523_ICD_BIN_GROUP,    "ISO 6523-ICD Group no, binary"},
4333
  { NSAP_IDI_LOCAL_DEC_GROUP,           "Local Group no, decimal"},
4334
  { NSAP_IDI_LOCAL_BIN_GROUP,           "Local Group no, binary"},
4335
  { NSAP_IDI_LOCAL_ISO_646_CHAR_GROUP,  "Local Group no, ISO/IEC 646 character"},
4336
  { NSAP_IDI_LOCAL_NATIONAL_CHAR_GROUP, "Local Group no, national character"},
4337
  { NSAP_IDI_X_121_DEC_FSD_Z_GROUP,     "X.121 Group no, decimal, first significant digit zero"},
4338
  { NSAP_IDI_X_121_BIN_FSD_Z_GROUP,     "X.121 Group no, binary, first significant digit zero"},
4339
  { NSAP_IDI_F_69_DEC_FSD_Z_GROUP,      "F.69 Group no, decimal, first significant digit zero"},
4340
  { NSAP_IDI_F_69_BIN_FSD_Z_GROUP,      "F.69 Group no, binary, first significant digit zero"},
4341
  { NSAP_IDI_E_163_DEC_FSD_Z_GROUP,     "E.163 Group no, decimal, first significant digit zero"},
4342
  { NSAP_IDI_E_163_BIN_FSD_Z_GROUP,     "E.163 Group no, binary, first significant digit zero"},
4343
  { NSAP_IDI_E_164_DEC_FSD_Z_GROUP,     "E.164 Group no, decimal, first significant digit zero"},
4344
  { NSAP_IDI_E_164_BIN_FSD_Z_GROUP,     "E.163 Group no, binary, first significant digit zero"},
4345
4346
  { NSAP_IDI_ITU_T_IND_DEC_GROUP,       "ITU-T IND Group no, decimal"},
4347
  { NSAP_IDI_ITU_T_IND_BIN_GROUP,       "ITU-T IND Group no, binary"},
4348
  { 0,  NULL }
4349
};
4350
value_string_ext x213_afi_value_ext = VALUE_STRING_EXT_INIT(x213_afi_value);
4351
4352
4353
/* Up-to-date information on the allocated ICP values can be found in   */
4354
/* RFC 4548 at                                                          */
4355
/* https://tools.ietf.org/html/rfc4548                                  */
4356
static const value_string iana_icp_values[] = {
4357
  { 0x0, "IP Version 6 Address"},
4358
  { 0x1, "IP Version 4 Address"},
4359
  { 0,  NULL }
4360
};
4361
4362
/*
4363
 * XXX - shouldn't there be a centralized routine for dissecting NSAPs?
4364
 * See also "dissect_atm_nsap()" in epan/dissectors/packet-arp.c and
4365
 * "print_nsap_net()" in epan/osi_utils.c.
4366
 */
4367
void
4368
dissect_nsap(tvbuff_t *parameter_tvb, packet_info* pinfo, unsigned offset, unsigned len, proto_tree *parameter_tree)
4369
335
{
4370
335
  uint8_t afi;
4371
335
  unsigned  icp;
4372
4373
335
  afi = tvb_get_uint8(parameter_tvb, offset);
4374
4375
335
  switch (afi) {
4376
6
    case NSAP_IDI_IANA_ICP_BIN:  /* IANA ICP Binary format*/
4377
6
      proto_tree_add_item(parameter_tree, hf_isup_idp, parameter_tvb, offset, 3, ENC_NA);
4378
4379
6
      proto_tree_add_uint(parameter_tree, hf_afi, parameter_tvb, offset, 1, afi);
4380
6
      offset = offset + 1;
4381
6
      icp = tvb_get_ntohs(parameter_tvb, offset);
4382
6
      proto_tree_add_uint(parameter_tree, hf_iana_icp, parameter_tvb, offset, 1, icp);
4383
6
      if (icp == 0) { /* IPv6 addr */
4384
1
        proto_tree_add_item(parameter_tree, hf_isup_dsp, parameter_tvb, offset + 2, 17, ENC_NA);
4385
1
        proto_tree_add_item(parameter_tree, hf_nsap_ipv6_addr, parameter_tvb, offset + 2,
4386
1
                            16, ENC_NA);
4387
4388
1
      }
4389
5
      else { /* IPv4 addr */
4390
        /* XXX - this is really only for ICP 1 */
4391
5
        proto_tree_add_item(parameter_tree, hf_isup_dsp, parameter_tvb, offset + 2, 17, ENC_NA);
4392
5
        proto_tree_add_item(parameter_tree, hf_nsap_ipv4_addr, parameter_tvb, offset + 2, 4, ENC_BIG_ENDIAN);
4393
5
      }
4394
4395
6
      break;
4396
1
    case NSAP_IDI_E_164_BIN_FSD_NZ:       /* E.164 ATM format */
4397
2
    case NSAP_IDI_E_164_BIN_FSD_NZ_GROUP: /* E.164 ATM group format */
4398
2
      proto_tree_add_item(parameter_tree, hf_isup_idp, parameter_tvb, offset, 9, ENC_NA);
4399
4400
2
      proto_tree_add_uint(parameter_tree, hf_afi, parameter_tvb, offset, 1, afi);
4401
4402
2
      proto_tree_add_item(parameter_tree, hf_isup_idi, parameter_tvb, offset + 1, 8, ENC_NA);
4403
2
      offset = offset +1;
4404
      /* Dissect country code */
4405
2
      dissect_e164_cc(parameter_tvb, pinfo, parameter_tree, offset, E164_ENC_BCD);
4406
4407
2
      proto_tree_add_uint_format_value(parameter_tree, hf_bicc_nsap_dsp_length, parameter_tvb, offset, 0,
4408
2
          (len-9), "%u (len %u -9)", (len-9), len);
4409
4410
2
      proto_tree_add_item(parameter_tree, hf_bicc_nsap_dsp, parameter_tvb, offset + 8, (len - 9), ENC_NA);
4411
4412
2
      break;
4413
327
    default:
4414
327
      proto_tree_add_uint(parameter_tree, hf_afi, parameter_tvb, offset, len, afi);
4415
335
  }/* end switch afi */
4416
4417
335
}
4418
4419
4420
0
#define  ACTION_INDICATOR                               0x01
4421
0
#define  BACKBONE_NETWORK_CONNECTION_IDENTIFIER         0x02
4422
0
#define  INTERWORKING_FUNCTION_ADDRESS                  0x03
4423
0
#define  CODEC_LIST                                     0x04
4424
0
#define  CODEC                                          0x05
4425
0
#define  BAT_COMPATIBILITY_REPORT                       0x06
4426
0
#define  BEARER_NETWORK_CONNECTION_CHARACTERISTICS      0x07
4427
0
#define  BEARER_CONTROL_INFORMATION                     0x08
4428
0
#define  BEARER_CONTROL_TUNNELLING                      0x09
4429
0
#define  BEARER_CONTROL_UNIT_IDENTIFIER                 0x0A
4430
0
#define  SIGNAL                                         0x0B
4431
0
#define  BEARER_REDIRECTION_CAPABILITY                  0x0C
4432
0
#define  BEARER_REDIRECTION_INDICATORS                  0x0D
4433
0
#define  SIGNAL_TYPE                                    0x0E
4434
0
#define  DURATION                                       0x0F
4435
4436
4437
static const value_string bat_ase_list_of_Identifiers_vals[] = {
4438
4439
  { 0x00                                        ,   "spare" },
4440
  { ACTION_INDICATOR                            ,   "Action Indicator" },
4441
  { BACKBONE_NETWORK_CONNECTION_IDENTIFIER      ,   "Backbone Network Connection Identifier" },
4442
  { INTERWORKING_FUNCTION_ADDRESS               ,   "Interworking Function Address" },
4443
  { CODEC_LIST                                  ,   "Codec List" },
4444
  { CODEC                                       ,   "Codec" },
4445
  { BAT_COMPATIBILITY_REPORT                    ,   "BAT Compatibility Report" },
4446
  { BEARER_NETWORK_CONNECTION_CHARACTERISTICS   ,   "Bearer Network Connection Characteristics" },
4447
  { BEARER_CONTROL_INFORMATION                  ,   "Bearer Control Information"},
4448
  { BEARER_CONTROL_TUNNELLING                   ,   "Bearer Control Tunnelling"},
4449
  { BEARER_CONTROL_UNIT_IDENTIFIER              ,   "Bearer Control Unit Identifier" },
4450
  { SIGNAL                                      ,   "Signal"},
4451
  { BEARER_REDIRECTION_CAPABILITY               ,   "Bearer Redirection Capability"},
4452
  { BEARER_REDIRECTION_INDICATORS               ,   "Bearer Redirection Indicators"},
4453
  { SIGNAL_TYPE                                 ,   "Signal Type"},
4454
  { DURATION                                    ,   "Duration" },
4455
  { 0,  NULL }
4456
};
4457
static value_string_ext bat_ase_list_of_Identifiers_vals_ext = VALUE_STRING_EXT_INIT(bat_ase_list_of_Identifiers_vals);
4458
4459
/*ITU-T Q.765.5 (06/2000) 13*/
4460
static const value_string Instruction_indicator_for_general_action_vals[] =
4461
{
4462
  { 0,  "Pass on information element"},
4463
  { 1,  "Discard information element"},
4464
  { 2,  "Discard BICC data"},
4465
  { 3,  "Release call"},
4466
  { 0,  NULL}};
4467
4468
static const value_string Instruction_indicator_for_pass_on_not_possible_vals[] = {
4469
  { 0,  "Release call"},
4470
  { 1,  "Discard information element"},
4471
  { 2,  "Discard BICC data"},
4472
  { 3,  "reserved (interpreted as 00)"},
4473
  { 0,  NULL}};
4474
4475
static const value_string bat_ase_action_indicator_field_vals[] = {
4476
4477
  { 0x00,  "no indication"},
4478
  { 0x01,  "connect backward"},
4479
  { 0x02,  "connect forward"},
4480
  { 0x03,  "connect forward, no notification"},
4481
  { 0x04,  "connect forward, plus notification"},
4482
  { 0x05,  "connect forward, no notification + selected codec"},
4483
  { 0x06,  "connect forward, plus notification + selected codec"},
4484
  { 0x07,  "use idle"},
4485
  { 0x08,  "connected"},
4486
  { 0x09,  "switched"},
4487
  { 0x0a,  "selected codec"},
4488
  { 0x0b,  "modify codec"},
4489
  { 0x0c,  "successful codec modification"},
4490
  { 0x0d,  "codec modification failure"},
4491
  { 0x0e,  "mid-call codec negotiation"},
4492
  { 0x0f,  "modify to selected codec information"},
4493
  { 0x10,  "mid-call codec negotiation failure"},
4494
  { 0x11,  "start signal, notify"},
4495
  { 0x12,  "start signal, no notify"},
4496
  { 0x13,  "stop signal, notify"},
4497
  { 0x14,  "stop signal, no notify"},
4498
  { 0x15,  "start signal acknowledge"},
4499
  { 0x16,  "start signal reject"},
4500
  { 0x17,  "stop signal acknowledge"},
4501
  { 0x18,  "bearer redirect"},
4502
  { 0,     NULL }
4503
};
4504
static value_string_ext bat_ase_action_indicator_field_vals_ext = VALUE_STRING_EXT_INIT(bat_ase_action_indicator_field_vals);
4505
4506
static const true_false_string BCTP_BVEI_value  = {
4507
  "Version Error Indication, BCTP version not supported",
4508
  "No indication"
4509
};
4510
4511
static const value_string BCTP_Tunnelled_Protocol_Indicator_vals[] = {
4512
4513
  { 0x20,  "IPBCP (text encoded)"},
4514
  { 0x21,  "spare (text encoded protocol)"},
4515
  { 0x22,  "not used"},
4516
  { 0,  NULL }
4517
};
4518
4519
static const true_false_string BCTP_TPEI_value  = {
4520
  "Protocol Error Indication, Bearer Control Protocol not supported",
4521
  "No indication"
4522
};
4523
4524
4525
0
#define  ITU_T  0x01
4526
0
#define  ETSI   0x02
4527
4528
static const value_string bat_ase_organization_identifier_subfield_vals[] = {
4529
4530
  { 0x00,   "no indication"},
4531
  { 0x01,   "ITU-T"},
4532
  { 0x02,   "ETSI (refer to TS 26.103)"},
4533
  { 0,  NULL }
4534
};
4535
4536
0
#define G_711_64_A            0x01
4537
0
#define G_711_64_U            0x02
4538
0
#define G_711_56_A            0x03
4539
0
#define G_711_56_U            0x04
4540
0
#define G_722_SB_ADPCM        0x05
4541
0
#define G_723_1               0x06
4542
0
#define G_723_1_Annex_A       0x07
4543
0
#define G_726_ADPCM           0x08
4544
0
#define G_727_Embedded_ADPCM  0x09
4545
0
#define G_728                 0x0a
4546
0
#define G_729_CS_ACELP        0x0b
4547
0
#define G_729_Annex_B         0x0c
4548
4549
static const value_string ITU_T_codec_type_subfield_vals[] = {
4550
4551
  { 0x00,                  "no indication"},
4552
  { G_711_64_A,            "G.711 64 kbit/s A-law"},
4553
  { G_711_64_U,            "G.711 64 kbit/s -law"},
4554
  { G_711_56_A,            "G.711 56 kbit/s A-law"},
4555
  { G_711_56_U,            "G.711 56 kbit/s -law"},
4556
  { G_722_SB_ADPCM,        "G.722 (SB-ADPCM)"},
4557
  { G_723_1,               "G.723.1"},
4558
  { G_723_1_Annex_A,       "G.723.1 Annex A (silence suppression)"},
4559
  { G_726_ADPCM,           "G.726 (ADPCM)"},
4560
  { G_727_Embedded_ADPCM,  "G.727 (Embedded ADPCM)"},
4561
  { G_728,                 "G.728"},
4562
  { G_729_CS_ACELP,        "G.729 (CS-ACELP)"},
4563
  { G_729_Annex_B,         "G.729 Annex B (silence suppression)"},
4564
  { 0,  NULL }
4565
};
4566
static value_string_ext ITU_T_codec_type_subfield_vals_ext = VALUE_STRING_EXT_INIT(ITU_T_codec_type_subfield_vals);
4567
4568
static const value_string ETSI_codec_type_subfield_vals[] = {
4569
4570
  { 0x00, "GSM Full Rate (13.0 kBit/s)(GSM FR)"},
4571
  { 0x01, "GSM Half Rate (5.6 kBit/s) (GSM HR)"},
4572
  { 0x02, "GSM Enhanced Full Rate (12.2 kBit/s)(GSM EFR)"},
4573
  { 0x03, "Full Rate Adaptive Multi-Rate (FR AMR)"},
4574
  { 0x04, "Half Rate Adaptive Multi-Rate (HR AMR)"},
4575
  { 0x05, "UMTS Adaptive Multi-Rate (UMTS AMR)"},
4576
  { 0x06, "UMTS Adaptive Multi-Rate 2 (UMTS AMR 2)"},
4577
  { 0x07, "TDMA Enhanced Full Rate (7.4 kBit/s) (TDMA EFR)"},
4578
  { 0x08, "PDC Enhanced Full Rate (6.7 kBit/s) (PDC EFR)"},
4579
  { 0x09, "Full Rate Adaptive Multi-Rate WideBand (FR AMR-WB)"},
4580
  { 0x0a, "UMTS Adaptive Multi-Rate WideBand (UMTS AMR-WB)"},
4581
  { 0x0b, "8PSK Half Rate Adaptive Multi-Rate (OHR AMR)"},
4582
  { 0x0c, "8PSK Full Rate Adaptive Multi-Rate WideBand  (OFR AMR-WB)"},
4583
  { 0x0d, "8PSK Half Rate Adaptive Multi-Rate WideBand (OHR AMR-WB)"},
4584
  { 0xfe, "Reserved for future use."},
4585
  { 0xff, "Reserved for MuMe dummy Codec Type (MuMe)"},
4586
  { 0,  NULL }
4587
};
4588
static value_string_ext ETSI_codec_type_subfield_vals_ext = VALUE_STRING_EXT_INIT(ETSI_codec_type_subfield_vals);
4589
4590
#if 0
4591
static const value_string bat_initial_codec_mode_vals[] = {
4592
  {0x7, "12.2 kbps"},
4593
  {0x6, "10.2 kbps"},
4594
  {0x5, "7.95 kbps"},
4595
  {0x4, "7.40 kbps"},
4596
  {0x3, "6.70 kbps"},
4597
  {0x2, "5.90 kbps"},
4598
  {0x1, "5.15 kbps"},
4599
  {0x0, "4.75 kbps"},
4600
  {0, NULL}
4601
};
4602
#endif
4603
4604
static const value_string optimisation_mode_vals[] = {
4605
  { 0,  "Optimisation of the ACS not supported,"},
4606
  { 1,  "Optimisation of the ACS supported,"},
4607
  { 0,  NULL }
4608
};
4609
4610
static const value_string bearer_network_connection_characteristics_vals[] = {
4611
4612
  { 0x00,   "no indication"},
4613
  { 0x01,   "AAL type 1"},
4614
  { 0x02,   "AAL type 2"},
4615
  { 0x03,   "Structured AAL type 1"},
4616
  { 0x04,   "IP/RTP"},
4617
  { 0x05,   "TDM (reserved for use by ITU-T Rec. Q.1950)"},
4618
  { 0,  NULL }
4619
};
4620
value_string_ext bearer_network_connection_characteristics_vals_ext = VALUE_STRING_EXT_INIT(bearer_network_connection_characteristics_vals);
4621
4622
static const true_false_string Bearer_Control_Tunnelling_ind_value  = {
4623
  "Tunnelling to be used",
4624
  "No indication"
4625
};
4626
4627
static const true_false_string late_cut_through_cap_ind_value  = {
4628
  "Late Cut-through supported",
4629
  "Late Cut-through not supported"
4630
};
4631
/*  ITU-T Rec. Q.765.5/Amd.1 (07/2001) */
4632
static const value_string Bearer_Redirection_Indicator_vals[] = {
4633
  { 0x00,  " no indication"},
4634
  { 0x01,  "late cut-through request"},
4635
  { 0x02,  "redirect temporary reject"},
4636
  { 0x03,  "redirect backwards request"},
4637
  { 0x04,  "redirect forwards request"},
4638
  { 0x05,  "redirect bearer release request"},
4639
  { 0x06,  "redirect bearer release proceed"},
4640
  { 0x07,  "redirect bearer release complete"},
4641
  { 0x08,  "redirect cut-through request"},
4642
  { 0x09,  "redirect bearer connected indication"},
4643
  { 0x0a,  "redirect failure"},
4644
  { 0x0b,  "new connection identifier"},
4645
  { 0,  NULL }
4646
};
4647
static value_string_ext Bearer_Redirection_Indicator_vals_ext = VALUE_STRING_EXT_INIT(Bearer_Redirection_Indicator_vals);
4648
4649
/*26/Q.765.5 - Signal Type */
4650
static const value_string BAT_ASE_Signal_Type_vals[] = {
4651
  { 0x00,  "DTMF 0"},
4652
  { 0x01,  "DTMF 1"},
4653
  { 0x02,  "DTMF 2"},
4654
  { 0x03,  "DTMF 3"},
4655
  { 0x04,  "DTMF 4"},
4656
  { 0x05,  "DTMF 5"},
4657
  { 0x06,  "DTMF 6"},
4658
  { 0x07,  "DTMF 7"},
4659
  { 0x08,  "DTMF 8"},
4660
  { 0x09,  "DTMF 9"},
4661
  { 0x0a,  "DTMF *"},
4662
  { 0x0b,  "DTMF #"},
4663
  { 0x0c,  "DTMF A"},
4664
  { 0x0d,  "DTMF B"},
4665
  { 0x0e,  "DTMF C"},
4666
  { 0x0f,  "DTMF D"},
4667
  /* 0001 0000
4668
   * to
4669
   * 0011 1111
4670
   * Spare
4671
   */
4672
  { 0x10,  "Spare"},
4673
  { 0x11,  "Spare"},
4674
  { 0x12,  "Spare"},
4675
  { 0x13,  "Spare"},
4676
  { 0x14,  "Spare"},
4677
  { 0x15,  "Spare"},
4678
  { 0x16,  "Spare"},
4679
  { 0x17,  "Spare"},
4680
  { 0x18,  "Spare"},
4681
  { 0x19,  "Spare"},
4682
  { 0x1a,  "Spare"},
4683
  { 0x1b,  "Spare"},
4684
  { 0x1c,  "Spare"},
4685
  { 0x1d,  "Spare"},
4686
  { 0x1e,  "Spare"},
4687
  { 0x1f,  "Spare"},
4688
  { 0x20,  "Spare"},
4689
  { 0x21,  "Spare"},
4690
  { 0x22,  "Spare"},
4691
  { 0x23,  "Spare"},
4692
  { 0x24,  "Spare"},
4693
  { 0x25,  "Spare"},
4694
  { 0x26,  "Spare"},
4695
  { 0x27,  "Spare"},
4696
  { 0x28,  "Spare"},
4697
  { 0x29,  "Spare"},
4698
  { 0x2a,  "Spare"},
4699
  { 0x2b,  "Spare"},
4700
  { 0x2c,  "Spare"},
4701
  { 0x2d,  "Spare"},
4702
  { 0x2e,  "Spare"},
4703
  { 0x2f,  "Spare"},
4704
  { 0x30,  "Spare"},
4705
  { 0x31,  "Spare"},
4706
  { 0x32,  "Spare"},
4707
  { 0x33,  "Spare"},
4708
  { 0x34,  "Spare"},
4709
  { 0x35,  "Spare"},
4710
  { 0x36,  "Spare"},
4711
  { 0x37,  "Spare"},
4712
  { 0x38,  "Spare"},
4713
  { 0x39,  "Spare"},
4714
  { 0x3a,  "Spare"},
4715
  { 0x3b,  "Spare"},
4716
  { 0x3c,  "Spare"},
4717
  { 0x3d,  "Spare"},
4718
  { 0x3e,  "Spare"},
4719
  { 0x3f,  "Spare"},
4720
4721
  { 0x40,  "dial tone"},
4722
  { 0x41,  "PABX internal dial tone"},
4723
  { 0x42,  "special dial tone"},
4724
  { 0x43,  "second dial tone"},
4725
  { 0x44,  "ringing tone"},
4726
  { 0x45,  "special ringing tone"},
4727
  { 0x46,  "busy tone"},
4728
  { 0x47,  "congestion tone"},
4729
  { 0x48,  "special information tone"},
4730
  { 0x49,  "warning tone"},
4731
  { 0x4a,  "intrusion tone"},
4732
  { 0x4b,  "call waiting tone"},
4733
  { 0x4c,  "pay tone"},
4734
  { 0x4d,  "payphone recognition tone"},
4735
  { 0x4e,  "comfort tone"},
4736
  { 0x4f,  "tone on hold"},
4737
  { 0x50,  "record tone"},
4738
  { 0x51,  "Caller waiting tone"},
4739
  { 0x52,  "positive indication tone"},
4740
  { 0x53,  "negative indication tone"},
4741
  { 0,  NULL }
4742
};
4743
static value_string_ext BAT_ASE_Signal_Type_vals_ext = VALUE_STRING_EXT_INIT(BAT_ASE_Signal_Type_vals);
4744
4745
static const value_string BAT_ASE_Report_Reason_vals[] = {
4746
4747
  { 0x00,   "no indication"},
4748
  { 0x01,   "information element non-existent or not implemented"},
4749
  { 0x02,   "BICC data with unrecognized information element, discarded"},
4750
  { 0,  NULL }
4751
};
4752
/* This routine should be called with offset at Organization_Identifier not the lengh indicator
4753
 * because of use from other dissectors.
4754
 */
4755
0
extern int dissect_codec_mode(proto_tree *tree, tvbuff_t *tvb, unsigned offset, unsigned len) {
4756
0
  uint8_t tempdata;
4757
0
  static int * const active_code_sets[] = {
4758
0
    &hf_active_code_set_12_2,
4759
0
    &hf_active_code_set_10_2,
4760
0
    &hf_active_code_set_7_95,
4761
0
    &hf_active_code_set_7_40,
4762
0
    &hf_active_code_set_6_70,
4763
0
    &hf_active_code_set_5_90,
4764
0
    &hf_active_code_set_5_15,
4765
0
    &hf_active_code_set_4_75,
4766
0
    NULL
4767
0
  };
4768
4769
0
  static int * const supported_code_sets[] = {
4770
0
    &hf_supported_code_set_12_2,
4771
0
    &hf_supported_code_set_10_2,
4772
0
    &hf_supported_code_set_7_95,
4773
0
    &hf_supported_code_set_7_40,
4774
0
    &hf_supported_code_set_6_70,
4775
0
    &hf_supported_code_set_5_90,
4776
0
    &hf_supported_code_set_5_15,
4777
0
    &hf_supported_code_set_4_75,
4778
0
    NULL
4779
0
  };
4780
4781
0
  tempdata = tvb_get_uint8(tvb, offset);
4782
0
  proto_tree_add_uint(tree, hf_Organization_Identifier , tvb, offset, 1, tempdata);
4783
0
  switch (tempdata) {
4784
0
    case ITU_T :
4785
0
      offset = offset + 1;
4786
0
      tempdata = tvb_get_uint8(tvb, offset);
4787
0
      proto_tree_add_uint(tree, hf_codec_type , tvb, offset, 1, tempdata);
4788
0
      offset = offset + 1;
4789
0
      switch (tempdata) {
4790
0
        case G_711_64_A :
4791
0
        case G_711_64_U :
4792
0
        case G_711_56_A :
4793
0
        case G_711_56_U :
4794
0
        case G_722_SB_ADPCM :
4795
0
        case G_723_1 :
4796
0
        case G_723_1_Annex_A :
4797
          /* These codecs have no configuration data */
4798
0
          break;
4799
0
        case G_726_ADPCM :
4800
0
        case G_727_Embedded_ADPCM :
4801
          /* four bit config data, TODO decode config */
4802
0
          if (len > 2) {
4803
0
            proto_tree_add_item(tree, hf_isup_configuration_data, tvb, offset, 1, ENC_NA);
4804
0
            offset = offset + 1;
4805
0
          }
4806
0
          break;
4807
0
        case G_728 :
4808
0
        case G_729_CS_ACELP :
4809
0
        case G_729_Annex_B :
4810
          /* three bit config data, TODO decode config */
4811
0
          if (len > 2) {
4812
0
            proto_tree_add_item(tree, hf_isup_configuration_data, tvb, offset, 1, ENC_NA);
4813
0
            offset = offset + 1;
4814
0
          }
4815
0
          break;
4816
0
        default:
4817
0
          break;
4818
4819
0
      }
4820
0
      break;
4821
0
    case ETSI:
4822
0
      offset = offset + 1;
4823
0
      tempdata = tvb_get_uint8(tvb, offset);
4824
0
      proto_tree_add_uint(tree, hf_etsi_codec_type , tvb, offset, 1, tempdata);
4825
0
      if (len > 2) {
4826
0
        offset = offset + 1;
4827
4828
0
        proto_tree_add_bitmask_with_flags(tree, tvb, offset, hf_active_code_set,
4829
0
                           ett_acs, active_code_sets, ENC_LITTLE_ENDIAN, BMT_NO_APPEND);
4830
0
      }
4831
0
      if (len > 3) {
4832
0
        offset = offset + 1;
4833
4834
0
        proto_tree_add_bitmask_with_flags(tree, tvb, offset, hf_supported_code_set,
4835
0
                           ett_acs, supported_code_sets, ENC_LITTLE_ENDIAN, BMT_NO_APPEND);
4836
0
      }
4837
0
      if (len > 4) {
4838
0
        offset = offset + 1;
4839
0
        proto_tree_add_item(tree, hf_optimisation_mode, tvb, offset, 1, ENC_LITTLE_ENDIAN);
4840
0
        proto_tree_add_item(tree, hf_max_codec_modes, tvb, offset, 1, ENC_LITTLE_ENDIAN);
4841
0
      }
4842
0
      offset = offset + 1;
4843
0
      break;
4844
0
    default:
4845
0
      offset = offset + 1;
4846
0
      proto_tree_add_item(tree, hf_isup_unknown_organisation_identifier, tvb, offset, len, ENC_NA);
4847
0
      offset = offset + len - 1;
4848
0
      break;
4849
0
  }
4850
  /* switch OID */
4851
4852
0
  return offset;
4853
0
}
4854
4855
static int
4856
dissect_codec(tvbuff_t *parameter_tvb, proto_tree *bat_ase_element_tree, int length_indicator, unsigned offset, int identifier)
4857
0
{
4858
/* offset is at length indicator e.g 1 step past identifier */
4859
0
  static int * const compatibility_info[] = {
4860
0
    &hf_Instruction_ind_for_general_action,
4861
0
    &hf_Send_notification_ind_for_general_action,
4862
0
    &hf_Instruction_ind_for_pass_on_not_possible,
4863
0
    &hf_Send_notification_ind_for_pass_on_not_possible,
4864
0
    &hf_isup_extension_ind,
4865
0
    NULL
4866
0
  };
4867
4868
0
  proto_tree_add_uint(bat_ase_element_tree , hf_bat_ase_identifier , parameter_tvb, offset - 1, 1, identifier);
4869
0
  proto_tree_add_uint(bat_ase_element_tree , hf_length_indicator  , parameter_tvb, offset, 1, length_indicator);
4870
0
  offset = offset + 1;
4871
4872
0
  proto_tree_add_bitmask_list(bat_ase_element_tree, parameter_tvb, offset, 1, compatibility_info, ENC_NA);
4873
4874
0
  offset = dissect_codec_mode(bat_ase_element_tree, parameter_tvb, offset+1, length_indicator-1);
4875
0
  return offset;
4876
0
}
4877
4878
/* Dissect BAT ASE message according to Q.765.5 200006 and Amendment 1 200107
4879
 * Layout of message        Length          Octet
4880
 *  Element name
4881
 *  Identifier                  1           1
4882
 *  Length indicator            1           2
4883
 *  Compatibility information   1           3
4884
 *  Contents                    1           4
4885
 *  Identifier                  n           m
4886
 *  Length indicator            n
4887
 *  Compatibility information   n
4888
 *  Contents                    n           p
4889
 */
4890
4891
static void
4892
dissect_bat_ase_Encapsulated_Application_Information(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, unsigned offset)
4893
0
{
4894
0
  unsigned    list_end;
4895
0
  tvbuff_t   *next_tvb;
4896
0
  proto_tree *bat_ase_tree, *bat_ase_element_tree, *bat_ase_iwfa_tree;
4897
0
  proto_item *bat_ase_element_item, *bat_ase_iwfa_item;
4898
0
  uint8_t     identifier, content, BCTP_Indicator_field_1, BCTP_Indicator_field_2;
4899
0
  uint8_t     tempdata, element_no, number_of_indicators;
4900
0
  uint16_t    sdp_length;
4901
0
  uint8_t     diagnostic_len;
4902
0
  uint8_t     length_ind_len;
4903
0
  unsigned    tempdata16;
4904
0
  unsigned    content_len, length_indicator;
4905
0
  unsigned    duration;
4906
0
  unsigned    diagnostic;
4907
0
  uint32_t    bncid;
4908
4909
0
  element_no = 0;
4910
4911
0
  bat_ase_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1, ett_bat_ase, NULL,
4912
0
                                     "Bearer Association Transport (BAT) Application Service Element (ASE) Encapsulated Application Information:");
4913
4914
0
  while (tvb_reported_length_remaining(parameter_tvb, offset) > 0) {
4915
0
    element_no = element_no + 1;
4916
0
    identifier = tvb_get_uint8(parameter_tvb, offset);
4917
4918
    /* length indicator may be 11 bits long */
4919
0
    offset = offset + 1;
4920
0
    proto_tree_add_item(bat_ase_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4921
0
    tempdata = tvb_get_uint8(parameter_tvb, offset);
4922
0
    if (tempdata & 0x80) {
4923
0
      length_indicator = tempdata & 0x7f;
4924
0
      length_ind_len = 1;
4925
0
    }
4926
0
    else {
4927
0
      offset = offset + 1;
4928
0
      tempdata16 = (tempdata & 0x7f);
4929
0
      length_indicator = tvb_get_uint8(parameter_tvb, offset)& 0x0f;
4930
0
      length_indicator = length_indicator << 7;
4931
0
      length_indicator = length_indicator + tempdata16;
4932
0
      length_ind_len = 2;
4933
0
    }
4934
4935
0
    bat_ase_element_tree = proto_tree_add_subtree_format(bat_ase_tree, parameter_tvb,
4936
0
                                               (offset - length_ind_len), (length_indicator + 2),
4937
0
                                               ett_bat_ase_element, &bat_ase_element_item,
4938
0
                                               "BAT ASE Element %u, Identifier: %s", element_no,
4939
0
                                               val_to_str_ext(pinfo->pool, identifier, &bat_ase_list_of_Identifiers_vals_ext, "unknown (%u)"));
4940
4941
0
    if (identifier != CODEC) {
4942
      /* identifier, length indicator and compatibility info must be printed inside CODEC */
4943
      /* dissection in order to use dissect_codec routine for codec list */
4944
0
      proto_tree_add_uint(bat_ase_element_tree , hf_bat_ase_identifier , parameter_tvb,
4945
0
                          offset - length_ind_len, 1, identifier);
4946
0
      proto_tree_add_uint(bat_ase_element_tree , hf_length_indicator  , parameter_tvb,
4947
0
                          offset - length_ind_len + 1, length_ind_len, length_indicator);
4948
4949
0
      offset = offset + 1;
4950
0
      proto_tree_add_item(bat_ase_element_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4951
0
      proto_tree_add_item(bat_ase_element_tree, hf_Send_notification_ind_for_pass_on_not_possible, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4952
0
      proto_tree_add_item(bat_ase_element_tree, hf_Instruction_ind_for_pass_on_not_possible, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4953
0
      proto_tree_add_item(bat_ase_element_tree, hf_Send_notification_ind_for_general_action, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4954
0
      proto_tree_add_item(bat_ase_element_tree, hf_Instruction_ind_for_general_action, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
4955
0
      offset = offset + 1;
4956
0
    }
4957
0
    content_len = length_indicator - 1 ; /* exclude the treated Compatibility information */
4958
4959
    /* content will be different depending on identifier */
4960
0
    switch (identifier) {
4961
4962
0
      case ACTION_INDICATOR :
4963
4964
0
        content = tvb_get_uint8(parameter_tvb, offset);
4965
0
        proto_tree_add_uint(bat_ase_element_tree, hf_Action_Indicator , parameter_tvb, offset, 1, content);
4966
0
        proto_item_append_text(bat_ase_element_item, " - %s",
4967
0
                               val_to_str_ext(pinfo->pool, content, &bat_ase_action_indicator_field_vals_ext, "unknown (%u)"));
4968
0
        offset = offset + 1;
4969
0
        break;
4970
0
      case BACKBONE_NETWORK_CONNECTION_IDENTIFIER :
4971
4972
0
        bncid = tvb_get_ntohl(parameter_tvb, offset);
4973
0
        switch (content_len) {
4974
0
          case 1:
4975
0
            bncid = bncid & 0x000000ff;
4976
0
            break;
4977
0
          case 2:
4978
0
            bncid = bncid & 0x0000ffff;
4979
0
            break;
4980
0
          case 3:
4981
0
            bncid = bncid & 0x00ffffff;
4982
0
            break;
4983
0
          case 4:;
4984
0
          default:;
4985
0
        }
4986
0
        proto_tree_add_uint_format(bat_ase_element_tree, hf_bncid, parameter_tvb, offset, content_len, bncid, "BNCId: 0x%08x", bncid);
4987
0
        proto_item_append_text(bat_ase_element_item, " - 0x%08x", bncid);
4988
0
        offset = offset + content_len;
4989
4990
0
        break;
4991
0
      case INTERWORKING_FUNCTION_ADDRESS :
4992
0
        bat_ase_iwfa_item = proto_tree_add_item(bat_ase_element_tree, hf_bat_ase_biwfa, parameter_tvb, offset, content_len,
4993
0
                                                ENC_NA);
4994
0
        bat_ase_iwfa_tree = proto_item_add_subtree(bat_ase_iwfa_item , ett_bat_ase_iwfa);
4995
0
        dissect_nsap(parameter_tvb, pinfo, offset, content_len, bat_ase_iwfa_tree);
4996
4997
0
        offset = offset + content_len;
4998
0
        break;
4999
0
      case CODEC_LIST :
5000
0
        list_end = offset + content_len;
5001
0
        while (offset < (list_end - 1)) {
5002
0
          identifier = tvb_get_uint8(parameter_tvb, offset);
5003
0
          offset = offset + 1;
5004
0
          tempdata = tvb_get_uint8(parameter_tvb, offset);
5005
0
          if (tempdata & 0x80) {
5006
0
            length_indicator = tempdata & 0x7f;
5007
0
          }
5008
0
          else {
5009
0
            offset = offset +1;
5010
0
            length_indicator = tvb_get_uint8(parameter_tvb, offset);
5011
0
            length_indicator = length_indicator << 7;
5012
0
            length_indicator = length_indicator & (tempdata & 0x7f);
5013
0
          }
5014
0
          offset = dissect_codec(parameter_tvb, bat_ase_element_tree, length_indicator , offset, identifier);
5015
0
        }
5016
0
        break;
5017
0
      case CODEC :
5018
        /* offset is at length indicator in this case */
5019
0
        offset = dissect_codec(parameter_tvb, bat_ase_element_tree, length_indicator , offset, identifier);
5020
0
        break;/* case codec */
5021
0
      case BAT_COMPATIBILITY_REPORT :
5022
0
        tempdata = tvb_get_uint8(parameter_tvb, offset);
5023
0
        proto_tree_add_uint(bat_ase_element_tree, hf_BAT_ASE_Comp_Report_Reason, parameter_tvb, offset, 1, tempdata);
5024
0
        offset = offset + 1;
5025
5026
0
        diagnostic_len = content_len - 1;
5027
0
        while (diagnostic_len > 0) {
5028
0
          tempdata = tvb_get_uint8(parameter_tvb, offset);
5029
0
          proto_tree_add_uint(bat_ase_element_tree, hf_BAT_ASE_Comp_Report_ident, parameter_tvb, offset, 1, tempdata);
5030
0
          offset = offset + 1;
5031
0
          diagnostic = tvb_get_letohs(parameter_tvb, offset);
5032
0
          proto_tree_add_uint(bat_ase_element_tree, hf_BAT_ASE_Comp_Report_diagnostic, parameter_tvb, offset, 2, diagnostic);
5033
0
          offset = offset + 2;
5034
0
          diagnostic_len = diagnostic_len - 3;
5035
0
        }
5036
0
        break;
5037
0
      case BEARER_NETWORK_CONNECTION_CHARACTERISTICS :
5038
0
        tempdata = tvb_get_uint8(parameter_tvb, offset);
5039
0
        proto_tree_add_uint(bat_ase_element_tree, hf_characteristics , parameter_tvb,
5040
0
                            offset, 1, tempdata);
5041
0
        proto_item_append_text(bat_ase_element_item, " - %s",
5042
0
                               val_to_str_ext(pinfo->pool, tempdata, &bearer_network_connection_characteristics_vals_ext, "unknown (%u)"));
5043
5044
0
        offset = offset + content_len;
5045
0
        break;
5046
/* The Bearer Control Information information element contains the bearer control tunnelling protocol */
5047
/* ITU-T Q.1990 (2001), BICC bearer control tunnelling protocol. */
5048
5049
0
      case BEARER_CONTROL_INFORMATION :
5050
0
        BCTP_Indicator_field_1 = tvb_get_uint8(parameter_tvb, offset);
5051
0
        proto_tree_add_uint(bat_ase_element_tree, hf_BCTP_Version_Indicator,
5052
0
                            parameter_tvb, offset, 1, BCTP_Indicator_field_1);
5053
5054
0
        proto_tree_add_boolean(bat_ase_element_tree, hf_BVEI,
5055
0
                               parameter_tvb, offset, 1, BCTP_Indicator_field_1);
5056
0
        offset = offset + 1;
5057
5058
0
        BCTP_Indicator_field_2 = tvb_get_uint8(parameter_tvb, offset);
5059
5060
0
        proto_tree_add_uint(bat_ase_element_tree, hf_Tunnelled_Protocol_Indicator ,
5061
0
                            parameter_tvb, offset, 1, BCTP_Indicator_field_2);
5062
5063
0
        proto_tree_add_boolean(bat_ase_element_tree, hf_TPEI,
5064
0
                               parameter_tvb, offset, 1, BCTP_Indicator_field_2);
5065
0
        offset = offset + 1;
5066
5067
0
        sdp_length = (length_indicator) - 3;
5068
5069
0
        if (sdp_length > tvb_reported_length_remaining(parameter_tvb, offset)) {
5070
          /* If this is a segmented message we may not have all the data */
5071
0
          next_tvb = tvb_new_subset_remaining(parameter_tvb, offset);
5072
0
        } else {
5073
0
          next_tvb = tvb_new_subset_length(parameter_tvb, offset, sdp_length);
5074
0
        }
5075
0
        if (BCTP_Indicator_field_2==0x20) {
5076
          /* IPBCP (text encoded) */
5077
0
          call_dissector(sdp_handle, next_tvb, pinfo, bat_ase_element_tree);
5078
0
        } else {
5079
0
          proto_tree_add_item(bat_ase_element_tree, hf_isup_tunnelled_protocol_data, next_tvb, 0, -1, ENC_NA);
5080
0
        }
5081
0
        offset = offset + sdp_length;
5082
0
        break;
5083
0
      case BEARER_CONTROL_TUNNELLING :
5084
5085
0
        tempdata = tvb_get_uint8(parameter_tvb, offset);
5086
0
        proto_tree_add_boolean(bat_ase_element_tree, hf_bearer_control_tunneling , parameter_tvb, offset, 1, (tempdata & 0x01));
5087
0
        if (tempdata & 0x01)
5088
0
          proto_item_append_text(bat_ase_element_item, " - Tunnelling to be used ");
5089
5090
0
        offset = offset + content_len;
5091
0
        break;
5092
0
      case BEARER_CONTROL_UNIT_IDENTIFIER :
5093
0
        tempdata = tvb_get_uint8(parameter_tvb, offset);
5094
0
        proto_tree_add_item(bat_ase_element_tree, hf_isup_network_id_length_indicator, parameter_tvb, offset, 1, ENC_NA);
5095
0
        offset = offset + 1;
5096
0
        if (tempdata > 0) {
5097
5098
/* Q.765.5 amd 1
5099
   Network ID
5100
   The coding of the Network ID field is identical to the coding of the Network ID field in the
5101
   Global Call Reference parameter as specified in clause 6/Q.1902.3 (see [3]).
5102
   NOTE .When used inside a network domain, the Network ID may be omitted by setting the
5103
   Network ID Length indicator to the value "0".
5104
   Q.1902.3
5105
   The following codes are used in the subfields of the global call reference parameter field:
5106
   a) Network ID
5107
   The Network ID contains the value field (coded according to ASN.1 BER) of an object
5108
   identifier identifying the network. This means that the tag and length fields are omitted.
5109
   An example of such an object identifier can be the following:
5110
   .{itu-t (0) administration (2) national regulatory authority (x) network (y)}
5111
   The value for x is the value of the national regulatory authority (one of the Data Country
5112
   Codes associated to the country as specified in ITU-T X.121 shall be used for "national
5113
   regulatory authority"), the value for y is under the control of the national regulatory
5114
   authority concerned.
5115
   b) Node ID
5116
   A binary number that uniquely identifies within the network the node which generates the
5117
   call reference.
5118
   c) Call Reference ID
5119
   A binary number used for the call reference of the call. This is generated by the node for
5120
   each call.
5121
5122
*/
5123
0
          proto_tree_add_item(bat_ase_element_tree, hf_isup_network_id, parameter_tvb, offset, tempdata, ENC_NA);
5124
0
          offset += tempdata;
5125
0
        } /* end if */
5126
5127
0
        proto_tree_add_item(bat_ase_element_tree, hf_Local_BCU_ID, parameter_tvb, offset, 4, ENC_LITTLE_ENDIAN);
5128
0
        offset += 4;
5129
0
        break;
5130
0
      case SIGNAL :
5131
        /* As type is Constructor new elements follow, return to main loop */
5132
0
        break;
5133
0
      case BEARER_REDIRECTION_CAPABILITY :
5134
0
        tempdata = tvb_get_uint8(parameter_tvb, offset);
5135
0
        proto_tree_add_boolean(bat_ase_element_tree, hf_late_cut_through_cap_ind , parameter_tvb, offset, 1, tempdata);
5136
0
        offset = offset + content_len;
5137
0
        break;
5138
0
      case BEARER_REDIRECTION_INDICATORS :
5139
0
        number_of_indicators = 0;
5140
0
        while (number_of_indicators < content_len) {
5141
0
          tempdata = tvb_get_uint8(parameter_tvb, offset);
5142
0
          proto_tree_add_uint(bat_ase_element_tree, hf_bat_ase_bearer_redir_ind , parameter_tvb, offset, 1, tempdata);
5143
0
          offset = offset + 1;
5144
0
          number_of_indicators = number_of_indicators + 1;
5145
0
        }
5146
0
        break;
5147
0
      case SIGNAL_TYPE :
5148
0
        tempdata = tvb_get_uint8(parameter_tvb, offset);
5149
0
        proto_tree_add_uint(bat_ase_element_tree, hf_bat_ase_signal , parameter_tvb, offset, 1, tempdata);
5150
0
        offset = offset + content_len;
5151
0
        break;
5152
0
      case DURATION :
5153
0
        duration = tvb_get_letohs(parameter_tvb, offset);
5154
0
        proto_tree_add_uint(bat_ase_element_tree, hf_bat_ase_duration , parameter_tvb, offset, 2, duration);
5155
0
        offset = offset + content_len;
5156
0
        break;
5157
0
      default :
5158
0
        proto_tree_add_item(bat_ase_element_tree, hf_bat_ase_default, parameter_tvb, offset, content_len, ENC_NA);
5159
0
        offset = offset + content_len;
5160
0
    }
5161
0
  }
5162
5163
0
}
5164
5165
5166
5167
/*
5168
Octet
5169
    -------------------------------------------
5170
1   | ext. Application context identifier lsb
5171
    -------------------------------------------
5172
1a  | ext. msb
5173
    -------------------------------------------
5174
2   | ext. spare                        SNI RCI
5175
    -------------------------------------------
5176
3   | ext. SI APM segmentation indicator
5177
    -------------------------------------------
5178
3a  | ext. Segmentation local reference
5179
    -------------------------------------------
5180
4a  |
5181
:   |   APM-user information
5182
4n  |
5183
    +-------------------------------------------
5184
5185
        Figure 77/Q.763 . Application transport parameter field
5186
*/
5187
static void
5188
dissect_isup_application_transport_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5189
23
{
5190
5191
23
  uint8_t  si_and_apm_seg_ind;
5192
23
  uint8_t  apm_Segmentation_local_ref = 0;
5193
23
  uint16_t aci16;
5194
23
  int      offset = 0;
5195
23
  uint8_t  octet;
5196
23
  unsigned length = tvb_reported_length(parameter_tvb);
5197
23
  bool more_frag;
5198
23
  bool save_fragmented;
5199
5200
23
  tvbuff_t      *new_tvb  = NULL;
5201
23
  tvbuff_t      *next_tvb = NULL;
5202
23
  fragment_head *frag_msg = NULL;
5203
5204
23
  static int * const apm_flags[] = {
5205
23
    &hf_isup_extension_ind,
5206
23
    &hf_isup_apm_si_ind,
5207
23
    &hf_isup_apm_segmentation_ind,
5208
23
    NULL
5209
23
  };
5210
5211
23
  static int * const app_trans_flags[] = {
5212
23
    &hf_isup_extension_ind,
5213
23
    &hf_isup_app_Send_notification_ind,
5214
23
    &hf_isup_app_Release_call_ind,
5215
23
    NULL
5216
23
  };
5217
5218
23
  static int * const app_field_flags[] = {
5219
23
    &hf_isup_extension_ind,
5220
23
    &hf_isup_app_cont_ident,
5221
23
    NULL
5222
23
  };
5223
5224
23
  aci16 = tvb_get_uint8(parameter_tvb, offset);
5225
5226
23
  if ((aci16 & H_8BIT_MASK) == 0x80) {
5227
    /* Octet 1 */
5228
9
    aci16 = aci16 & 0x7f;
5229
9
    proto_tree_add_bitmask(parameter_tree, parameter_tvb, offset, hf_isup_app_transport_param_field8, ett_app_transport_fields, app_field_flags, ENC_NA);
5230
9
    offset = offset + 1;
5231
9
  }
5232
  /* Octet 1a */
5233
14
  else {
5234
14
    proto_tree_add_item(parameter_tree, hf_isup_app_transport_param_field16, parameter_tvb, offset, 2, ENC_BIG_ENDIAN);
5235
14
    aci16 = (aci16<<8) | (tvb_get_uint8(parameter_tvb, offset) & 0x7f);
5236
14
    proto_tree_add_uint(parameter_tree, hf_isup_app_cont_ident , parameter_tvb, offset, 2, aci16);
5237
14
    offset = offset + 2;
5238
14
  }
5239
5240
  /* Octet 2 */
5241
23
  proto_tree_add_bitmask(parameter_tree, parameter_tvb, offset, hf_isup_app_transport_instruction_indicator, ett_app_transport, app_trans_flags, ENC_NA);
5242
23
  offset = offset + 1;
5243
5244
  /* Octet 3*/
5245
23
  si_and_apm_seg_ind  = tvb_get_uint8(parameter_tvb, offset);
5246
23
  proto_tree_add_bitmask(parameter_tree, parameter_tvb, offset, hf_isup_apm_seg_indicator, ett_apm_seg_indicator, apm_flags, ENC_NA);
5247
23
  offset = offset + 1;
5248
5249
  /* Octet 3a */
5250
23
  if ((si_and_apm_seg_ind & H_8BIT_MASK) == 0x00) {
5251
19
    apm_Segmentation_local_ref  = tvb_get_uint8(parameter_tvb, offset);
5252
19
    proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5253
19
    proto_tree_add_item(parameter_tree, hf_isup_apm_slr, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5254
19
    offset = offset + 1;
5255
19
  }
5256
  /* For APM'98'-user applications. (aci 0 - 3), APM-user information field starts at octet 4 */
5257
23
  if (aci16 > 3) {
5258
    /* Octet 4 Originating Address length */
5259
19
    octet = tvb_get_uint8(parameter_tvb, offset);
5260
19
    proto_tree_add_item(parameter_tree, hf_isup_orig_addr_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5261
19
    offset += 1;
5262
19
    if (octet != 0) {
5263
      /* 4b */
5264
16
      proto_tree_add_item(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5265
      /* nature of address indicator */
5266
16
      offset += 1;
5267
16
      proto_tree_add_item(parameter_tree, hf_isup_inn_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5268
16
      proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5269
16
      offset += 1;
5270
      /* Address digits */
5271
16
      proto_tree_add_item(parameter_tree, hf_isup_address_digits, parameter_tvb, offset, octet - 2, ENC_NA);
5272
16
      offset = offset + octet - 2;
5273
16
    }
5274
    /* Octet 5 Destination Address length */
5275
19
    octet = tvb_get_uint8(parameter_tvb, offset);
5276
19
    proto_tree_add_item(parameter_tree, hf_isup_dest_addr_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5277
19
    offset += 1;
5278
19
    if (octet != 0) {
5279
      /* 4b */
5280
10
      proto_tree_add_item(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5281
      /* nature of address indicator */
5282
10
      offset += 1;
5283
10
      proto_tree_add_item(parameter_tree, hf_isup_inn_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5284
10
      proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
5285
10
      offset += 1;
5286
      /* Address digits */
5287
10
      proto_tree_add_item(parameter_tree, hf_isup_address_digits, parameter_tvb, offset, octet - 2, ENC_NA);
5288
10
      offset = offset + octet - 2;
5289
10
    }
5290
19
  }
5291
  /*
5292
   * Defragment ?
5293
   *
5294
   */
5295
23
  if (isup_apm_desegment) {
5296
19
    if ((si_and_apm_seg_ind != 0xc0) && ((si_and_apm_seg_ind & H_8BIT_MASK)!=0x80)) {
5297
      /* debug ws_warning("got here Frame %u", pinfo->num); */
5298
      /* Segmented message */
5299
17
      save_fragmented = pinfo->fragmented;
5300
17
      pinfo->fragmented = true;
5301
17
      more_frag = true;
5302
17
      if (si_and_apm_seg_ind == 0)
5303
4
        more_frag = false;
5304
5305
17
      frag_msg = fragment_add_seq_next(&isup_apm_msg_reassembly_table,
5306
17
                                       parameter_tvb, offset,
5307
17
                                       pinfo,
5308
17
                                       (apm_Segmentation_local_ref & 0x7f),         /* ID for fragments belonging together */
5309
17
                                       NULL,
5310
17
                                       tvb_reported_length_remaining(parameter_tvb, offset), /* fragment length - to the end */
5311
17
                                       more_frag);                                  /* More fragments? */
5312
5313
17
      if ((si_and_apm_seg_ind & 0x3f) !=0 && (si_and_apm_seg_ind &0x40) !=0) {
5314
        /* First fragment set number of fragments */
5315
9
        fragment_set_tot_len(&isup_apm_msg_reassembly_table,
5316
9
                             pinfo,
5317
9
                             apm_Segmentation_local_ref & 0x7f,
5318
9
                             NULL,
5319
9
                             (si_and_apm_seg_ind & 0x3f));
5320
9
      }
5321
5322
17
      new_tvb = process_reassembled_data(parameter_tvb, offset, pinfo,
5323
17
                                         "Reassembled ISUP", frag_msg, &isup_apm_msg_frag_items,
5324
17
                                         NULL, parameter_tree);
5325
5326
17
      if (frag_msg) { /* Reassembled */
5327
4
        col_append_str(pinfo->cinfo, COL_INFO,
5328
4
                       " (Message Reassembled)");
5329
13
      } else { /* Not last packet of reassembled Short Message */
5330
13
        col_append_str(pinfo->cinfo, COL_INFO,
5331
13
                       " (Message fragment)");
5332
13
      }
5333
5334
17
      pinfo->fragmented = save_fragmented;
5335
17
    }
5336
19
  }/*isup_apm_desegment*/
5337
5338
23
  if (offset == (int)length) {
5339
    /* No data */
5340
0
    proto_tree_add_item(parameter_tree, hf_isup_apm_user_info_field, parameter_tvb, offset, 0, ENC_NA);
5341
0
    return;
5342
0
  }
5343
23
  if (new_tvb) { /* take it all */
5344
4
    next_tvb = new_tvb;
5345
19
  } else { /* make a new subset */
5346
19
    next_tvb = tvb_new_subset_remaining(parameter_tvb, offset);
5347
19
  }
5348
5349
23
  proto_tree_add_item(parameter_tree, hf_isup_apm_user_info_field, parameter_tvb, offset, -1, ENC_NA);
5350
5351
23
  switch (aci16 & 0x7fff) {
5352
0
    case 3:
5353
      /* Charging ASE */
5354
0
      dissect_charging_ase_ChargingMessageType_PDU(next_tvb, pinfo, parameter_tree, NULL);
5355
0
      break;
5356
0
    case 5:
5357
      /* dissect BAT ASE element, without transparent data (Q.765.5-200006) */
5358
0
      dissect_bat_ase_Encapsulated_Application_Information(next_tvb, pinfo, parameter_tree, 0);
5359
0
      break;
5360
19
    default:
5361
19
      expert_add_info_format(pinfo, parameter_tree, &ei_isup_not_dissected_yet, "No further dissection of APM-user information field");
5362
19
      break;
5363
23
  }
5364
23
}
5365
5366
5367
5368
/* ------------------------------------------------------------------
5369
  Dissector Parameter Optional Forward Call indicators
5370
 */
5371
static void
5372
dissect_isup_optional_forward_call_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5373
89
{
5374
89
  uint8_t ind;
5375
89
  static int * const indicators[] = {
5376
89
    &hf_isup_cug_call_ind,
5377
89
    &hf_isup_simple_segmentation_ind,
5378
89
    &hf_isup_connected_line_identity_request_ind,
5379
89
    NULL
5380
89
  };
5381
5382
89
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, OPTIONAL_FORWARD_CALL_IND_LENGTH, indicators, ENC_NA);
5383
5384
89
  ind = tvb_get_uint8(parameter_tvb, 0);
5385
89
  proto_item_append_text(parameter_item, " : %s (%u)",
5386
89
                      val_to_str_const(ind & BA_8BIT_MASK, isup_CUG_call_ind_value, "spare"),
5387
89
                      ind);
5388
89
}
5389
/* ------------------------------------------------------------------
5390
  Dissector Parameter calling party number
5391
 */
5392
void
5393
dissect_isup_calling_party_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
5394
112
{
5395
112
  uint8_t      indicators1, indicators2;
5396
112
  int          offset = 0;
5397
112
  int          number_plan;
5398
112
  static int * const indicators1_fields[] = {
5399
112
    &hf_isup_odd_even_indicator,
5400
112
    &hf_isup_calling_party_nature_of_address_indicator,
5401
112
    NULL
5402
112
  };
5403
112
  static int * const indicators2_fields[] = {
5404
112
    &hf_isup_ni_indicator,
5405
112
    &hf_isup_numbering_plan_indicator,
5406
112
    &hf_isup_address_presentation_restricted_indicator,
5407
112
    &hf_isup_screening_indicator,
5408
112
    NULL
5409
112
  };
5410
5411
112
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
5412
112
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
5413
112
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
5414
112
  indicators2 = tvb_get_uint8(parameter_tvb, 1);
5415
112
  number_plan = (indicators2 & 0x70)>> 4;
5416
112
  offset = 2;
5417
5418
112
  tap_calling_number = dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
5419
112
                             hf_isup_calling, hf_isup_calling_party_odd_address_signal_digit,
5420
112
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
5421
112
                             number_plan == 1 ? CALLING_PARTY_NUMBER : NONE,
5422
112
                             (indicators1 & 0x7f));
5423
112
}
5424
/* ------------------------------------------------------------------
5425
  Dissector Parameter Original called  number
5426
 */
5427
void
5428
dissect_isup_original_called_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
5429
33
{
5430
33
  uint8_t     indicators1;
5431
33
  int         offset = 0;
5432
33
  static int * const indicators1_fields[] = {
5433
33
    &hf_isup_odd_even_indicator,
5434
33
    &hf_isup_calling_party_nature_of_address_indicator,
5435
33
    NULL
5436
33
  };
5437
33
  static int * const indicators2_fields[] = {
5438
33
    &hf_isup_numbering_plan_indicator,
5439
33
    &hf_isup_address_presentation_restricted_indicator,
5440
33
    NULL
5441
33
  };
5442
5443
5444
33
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
5445
33
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
5446
33
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
5447
33
  offset = 2;
5448
5449
33
  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
5450
33
                             hf_isup_original_called_number,
5451
33
                             hf_isup_calling_party_odd_address_signal_digit,
5452
33
                             hf_isup_calling_party_even_address_signal_digit,
5453
33
                             ((indicators1 & 0x80) == 0), NONE, 0);
5454
33
}
5455
/* ------------------------------------------------------------------
5456
  Dissector Parameter Redirecting number
5457
 */
5458
void
5459
dissect_isup_redirecting_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
5460
191
{
5461
191
  uint8_t     indicators1;
5462
191
  int         offset = 0;
5463
191
  static int * const indicators1_fields[] = {
5464
191
    &hf_isup_odd_even_indicator,
5465
191
    &hf_isup_calling_party_nature_of_address_indicator,
5466
191
    NULL
5467
191
  };
5468
191
  static int * const indicators2_fields[] = {
5469
191
    &hf_isup_numbering_plan_indicator,
5470
191
    &hf_isup_address_presentation_restricted_indicator,
5471
191
    NULL
5472
191
  };
5473
5474
191
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
5475
191
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
5476
191
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
5477
191
  offset = 2;
5478
5479
191
  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
5480
191
                             hf_isup_redirecting, hf_isup_calling_party_odd_address_signal_digit,
5481
191
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
5482
191
                             NONE, 0);
5483
191
}
5484
5485
/* ------------------------------------------------------------------
5486
  Dissector Parameter Redirection number
5487
 */
5488
static void
5489
dissect_isup_redirection_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
5490
109
{
5491
109
  uint8_t     indicators1;
5492
109
  int         offset = 0;
5493
109
  static int * const indicators1_fields[] = {
5494
109
    &hf_isup_odd_even_indicator,
5495
109
    &hf_isup_called_party_nature_of_address_indicator,
5496
109
    NULL
5497
109
  };
5498
109
  static int * const indicators2_fields[] = {
5499
109
    &hf_isup_inn_indicator,
5500
109
    &hf_isup_numbering_plan_indicator,
5501
109
    NULL
5502
109
  };
5503
5504
109
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
5505
109
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
5506
109
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
5507
109
  offset = 2;
5508
5509
109
  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
5510
109
                             hf_isup_redirection_number, hf_isup_called_party_odd_address_signal_digit,
5511
109
                             hf_isup_called_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
5512
109
                             NONE, 0);
5513
109
}
5514
5515
/* ------------------------------------------------------------------
5516
  Dissector Parameter Connection request
5517
 */
5518
static void
5519
dissect_isup_connection_request_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5520
120
{
5521
120
  uint32_t local_ref;
5522
120
  uint16_t spc;
5523
120
  uint8_t protocol_class, credit, offset = 0;
5524
5525
120
  local_ref = tvb_get_ntoh24(parameter_tvb, 0);
5526
120
  proto_tree_add_item(parameter_tree, hf_isup_local_reference, parameter_tvb, offset, LOCAL_REF_LENGTH, ENC_BIG_ENDIAN);
5527
120
  offset = LOCAL_REF_LENGTH;
5528
120
  spc = tvb_get_letohs(parameter_tvb, offset) & 0x3FFF; /*since 1st 2 bits spare */
5529
120
  proto_tree_add_item(parameter_tree, hf_isup_signalling_point_code, parameter_tvb, offset, SPC_LENGTH, ENC_BIG_ENDIAN);
5530
120
  offset += SPC_LENGTH;
5531
120
  proto_tree_add_item_ret_uint8(parameter_tree, hf_isup_protocol_class, parameter_tvb, offset, PROTOCOL_CLASS_LENGTH, ENC_BIG_ENDIAN, &protocol_class);
5532
120
  offset += PROTOCOL_CLASS_LENGTH;
5533
120
  proto_tree_add_item_ret_uint8(parameter_tree, hf_isup_credit, parameter_tvb, offset, CREDIT_LENGTH, ENC_BIG_ENDIAN, &credit);
5534
5535
120
  proto_item_append_text(parameter_item,
5536
120
                      " : Local Reference = %u, SPC = %u, Protocol Class = %u, Credit = %u",
5537
120
                      local_ref, spc, protocol_class, credit);
5538
120
}
5539
/* ------------------------------------------------------------------
5540
  Dissector Parameter Redirection information
5541
 */
5542
void
5543
dissect_isup_redirection_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5544
48
{
5545
48
  if (tvb_reported_length(parameter_tvb) == 2) {
5546
2
    uint16_t indicators;
5547
2
    indicators = tvb_get_ntohs(parameter_tvb, 0);
5548
2
    proto_tree_add_uint(parameter_tree, hf_isup_redirecting_ind, parameter_tvb, 0, REDIRECTION_INFO_LENGTH, indicators);
5549
2
    proto_tree_add_uint(parameter_tree, hf_isup_original_redirection_reason, parameter_tvb, 0, REDIRECTION_INFO_LENGTH, indicators);
5550
2
    proto_tree_add_uint(parameter_tree, hf_isup_redirection_counter, parameter_tvb, 0, REDIRECTION_INFO_LENGTH, indicators);
5551
2
    proto_tree_add_uint(parameter_tree, hf_isup_redirection_reason, parameter_tvb, 0, REDIRECTION_INFO_LENGTH, indicators);
5552
2
  }
5553
46
  else { /* ISUP'88 (blue book) */
5554
46
    uint16_t indicators;
5555
46
    indicators = tvb_get_uint8(parameter_tvb, 0) * 0x100; /*since 2nd octet isn't present*/
5556
46
    proto_tree_add_uint(parameter_tree, hf_isup_redirecting_ind, parameter_tvb, 0, 1, indicators);
5557
46
    proto_tree_add_uint(parameter_tree, hf_isup_original_redirection_reason, parameter_tvb, 0, 1, indicators);
5558
46
    proto_item_append_text(parameter_item, " (2nd octet not present since ISUP '88)");
5559
46
  }
5560
48
}
5561
/* ------------------------------------------------------------------
5562
  Dissector Parameter Closed user group interlock code
5563
 */
5564
static void
5565
dissect_isup_closed_user_group_interlock_code_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5566
108
{
5567
108
  char    NI_digits[5] = "";
5568
108
  uint8_t digit_pair;
5569
108
  uint16_t bin_code;
5570
5571
108
  digit_pair = tvb_get_uint8(parameter_tvb, 0);
5572
108
  NI_digits[0] = number_to_char((digit_pair & HGFE_8BIT_MASK) / 0x10);
5573
108
  NI_digits[1] = number_to_char(digit_pair & DCBA_8BIT_MASK);
5574
108
  digit_pair = tvb_get_uint8(parameter_tvb, 1);
5575
108
  NI_digits[2] = number_to_char((digit_pair & HGFE_8BIT_MASK) / 0x10);
5576
108
  NI_digits[3] = number_to_char(digit_pair & DCBA_8BIT_MASK);
5577
108
  NI_digits[4] = '\0';
5578
108
  proto_tree_add_string(parameter_tree, hf_isup_network_identity, parameter_tvb, 0, 2, NI_digits);
5579
108
  bin_code = tvb_get_ntohs(parameter_tvb, 2);
5580
108
  proto_tree_add_item(parameter_tree, hf_isup_binary_code, parameter_tvb, 2, 2, ENC_BIG_ENDIAN);
5581
108
  proto_item_append_text(parameter_item, " : NI = %s, Binary code = 0x%x", NI_digits, bin_code);
5582
108
}
5583
/* ------------------------------------------------------------------
5584
  Dissector Parameter User service information- no detailed dissection since defined in Rec. Q.931
5585
 */
5586
static void
5587
dissect_isup_user_service_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5588
30
{ unsigned length = tvb_reported_length(parameter_tvb);
5589
30
  proto_tree_add_item(parameter_tree, hf_isup_user_service_information, parameter_tvb, 0, length, ENC_NA);
5590
30
  dissect_q931_bearer_capability_ie(parameter_tvb,
5591
30
                                    0, length,
5592
30
                                    parameter_tree);
5593
30
}
5594
/* ------------------------------------------------------------------
5595
  Dissector Parameter Signalling point code
5596
 */
5597
static void
5598
dissect_isup_signalling_point_code_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5599
14
{
5600
14
  uint16_t spc;
5601
5602
14
  spc = tvb_get_letohs(parameter_tvb, 0) & 0x3FFF; /*since 1st 2 bits spare */
5603
14
  proto_tree_add_item(parameter_tree, hf_isup_signalling_point_code, parameter_tvb, 0, SIGNALLING_POINT_CODE_LENGTH, ENC_BIG_ENDIAN);
5604
5605
14
  proto_item_append_text(parameter_item, " : %u", spc);
5606
14
}
5607
/* ------------------------------------------------------------------
5608
  Dissector Parameter Connected number
5609
 */
5610
static void
5611
dissect_isup_connected_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
5612
35
{
5613
35
  uint8_t     indicators1;
5614
35
  int         offset = 0;
5615
35
  static int * const indicators1_fields[] = {
5616
35
    &hf_isup_odd_even_indicator,
5617
35
    &hf_isup_calling_party_nature_of_address_indicator,
5618
35
    NULL
5619
35
  };
5620
35
  static int * const indicators2_fields[] = {
5621
35
    &hf_isup_numbering_plan_indicator,
5622
35
    &hf_isup_address_presentation_restricted_indicator,
5623
35
    &hf_isup_screening_indicator,
5624
35
    NULL
5625
35
  };
5626
5627
35
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
5628
35
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
5629
35
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
5630
35
  offset = 2;
5631
5632
35
  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
5633
35
                             hf_isup_connected_number, hf_isup_calling_party_odd_address_signal_digit,
5634
35
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
5635
35
                             NONE, 0);
5636
35
}
5637
5638
/* ------------------------------------------------------------------
5639
  Dissector Transit network selection
5640
 */
5641
static void
5642
dissect_isup_transit_network_selection_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
5643
16
{
5644
16
  uint8_t     indicators1;
5645
16
  int         offset = 0;
5646
16
  static int * const indicators_fields[] = {
5647
16
    &hf_isup_odd_even_indicator,
5648
16
    &hf_isup_type_of_network_identification,
5649
16
    &hf_isup_network_identification_plan,
5650
16
    NULL
5651
16
  };
5652
5653
16
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators_fields, ENC_NA);
5654
16
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
5655
16
  offset = 1;
5656
5657
16
  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
5658
16
                             hf_isup_transit_network_selection, hf_isup_calling_party_odd_address_signal_digit,
5659
16
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
5660
16
                             NONE, 0);
5661
16
}
5662
5663
/* ------------------------------------------------------------------
5664
  Dissector Parameter Circuit assignment map
5665
 */
5666
static void
5667
dissect_isup_circuit_assignment_map_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5668
25
{ uint8_t map_type;
5669
5670
25
  map_type = tvb_get_uint8(parameter_tvb, 0);
5671
25
  proto_tree_add_uint(parameter_tree, hf_isup_map_type, parameter_tvb, 0, 1, map_type);
5672
25
  proto_tree_add_item(parameter_tree, hf_isup_circuit_assignment_map, parameter_tvb, 1, 5, ENC_NA);
5673
25
}
5674
/* ------------------------------------------------------------------
5675
  Dissector Parameter Automatic congestion level
5676
 */
5677
static void
5678
dissect_isup_automatic_congestion_level_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5679
24
{ uint8_t congestion_level;
5680
5681
24
  congestion_level = tvb_get_uint8(parameter_tvb, 0);
5682
24
  proto_tree_add_uint(parameter_tree, hf_isup_automatic_congestion_level, parameter_tvb, 0, AUTO_CONGEST_LEVEL_LENGTH, congestion_level);
5683
24
  proto_item_append_text(parameter_item, " : %s (%u)",
5684
24
                      val_to_str_const(congestion_level, isup_auto_congestion_level_value, "spare"), congestion_level);
5685
24
}
5686
/* ------------------------------------------------------------------
5687
  Dissector Parameter Optional backward Call indicators
5688
 */
5689
static void
5690
dissect_isup_optional_backward_call_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5691
27
{
5692
27
  static int * const indicators[] = {
5693
27
    &hf_isup_inband_information_ind,
5694
27
    &hf_isup_call_diversion_may_occur_ind,
5695
27
    &hf_isup_simple_segmentation_ind,
5696
27
    &hf_isup_mlpp_user_ind,
5697
27
    NULL
5698
27
  };
5699
5700
27
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, OPTIONAL_BACKWARD_CALL_IND_LENGTH, indicators, ENC_NA);
5701
5702
27
  proto_item_append_text(parameter_item, " : 0x%x", tvb_get_uint8(parameter_tvb, 0));
5703
27
}
5704
/* ------------------------------------------------------------------
5705
  Dissector Parameter User-to-user indicators
5706
 */
5707
static const value_string isup_UUI_request_service_values[] = {
5708
  { 0,  "No information"},
5709
  { 1,  "Spare"},
5710
  { 2,  "Request, not essential"},
5711
  { 3,  "Request,essential"},
5712
  { 0,  NULL}
5713
};
5714
5715
static const value_string isup_UUI_response_service_values[] = {
5716
  { 0,  "No information"},
5717
  { 1,  "Not provided"},
5718
  { 2,  "Provided"},
5719
  { 3,  "Spare"},
5720
  { 0,  NULL}
5721
};
5722
static const true_false_string isup_UUI_network_discard_ind_value = {
5723
  "User-to-user information discarded by the network",
5724
  "No information"
5725
};
5726
5727
static void
5728
dissect_isup_user_to_user_indicators_parameter(tvbuff_t *parameter_tvb,
5729
                                               proto_tree *parameter_tree,
5730
                                               proto_item *parameter_item)
5731
36
{
5732
36
  uint8_t indicators;
5733
36
  static int * const req_fields[] = {
5734
36
    &hf_isup_UUI_type,
5735
36
    &hf_isup_UUI_req_service1,
5736
36
    &hf_isup_UUI_req_service2,
5737
36
    &hf_isup_UUI_req_service3,
5738
36
    NULL
5739
36
  };
5740
36
  static int * const res_fields[] = {
5741
36
    &hf_isup_UUI_type,
5742
36
    &hf_isup_UUI_res_service1,
5743
36
    &hf_isup_UUI_res_service2,
5744
36
    &hf_isup_UUI_res_service3,
5745
36
    &hf_isup_UUI_network_discard_ind,
5746
36
    NULL
5747
36
  };
5748
5749
36
  indicators = tvb_get_uint8(parameter_tvb, 0);
5750
36
  proto_tree_add_boolean(parameter_tree, hf_isup_UUI_type, parameter_tvb, 0, 1, indicators);
5751
36
  if ((indicators & 0x01) == 0) {
5752
    /* Request */
5753
26
    proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, req_fields, ENC_NA);
5754
26
  }
5755
10
  else {
5756
    /* Response */
5757
10
    proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, res_fields, ENC_NA);
5758
10
  }
5759
36
  proto_item_append_text(parameter_item, " : 0x%x", indicators);
5760
36
}
5761
/* ------------------------------------------------------------------
5762
  Dissector Parameter Original ISC point code
5763
 */
5764
static void
5765
dissect_isup_original_isc_point_code_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5766
20
{
5767
20
  uint16_t spc;
5768
5769
20
  spc = tvb_get_letohs(parameter_tvb, 0) & 0x3FFF; /*since 1st 2 bits spare */
5770
20
  proto_tree_add_item(parameter_tree, hf_isup_origination_isc_point_code, parameter_tvb, 0, ORIGINAL_ISC_POINT_CODE_LENGTH, ENC_BIG_ENDIAN);
5771
5772
20
  proto_item_append_text(parameter_item, " : %u", spc);
5773
20
}
5774
/* ------------------------------------------------------------------
5775
   Dissector Parameter Generic notification indicator
5776
5777
   3.25 Generic notification indicator
5778
5779
   a) Extension indicator (ext.)
5780
   0 information continues in the next octet
5781
   1 last octet
5782
5783
   b) Notification indicator
5784
   0 0 0 0 0 0 0 user suspended
5785
   0 0 0 0 0 0 1 user resumed
5786
   0 0 0 0 0 1 0 bearer service change
5787
   0 0 0 0 0 1 1 encoded component discriminator for extension to ASN.1 (used in DSS1)
5788
   0 0 0 0 1 0 0 call completion delay
5789
   
5790
   1 0 0 0 0 0 1
5791
   to
5792
   0 0 0 0 1 0 1 reserved
5793
5794
   1 0 0 0 0 1 0 conference established
5795
   1 0 0 0 0 1 1 conference disconnected
5796
   1 0 0 0 1 0 0 other party added
5797
   1 0 0 0 1 0 1 isolated
5798
   1 0 0 0 1 1 0 reattached
5799
   1 0 0 0 1 1 1 other party isolated
5800
   1 0 0 1 0 0 0 other party reattached
5801
   1 0 0 1 0 0 1 other party split
5802
   1 0 0 1 0 1 0 other party disconnected
5803
   1 0 0 1 0 1 1 conference floating
5804
   
5805
   1 0 1 1 1 1 1
5806
   to
5807
   1 0 0 1 1 0 0 reserved
5808
5809
   1 1 0 0 0 0 0 call is a waiting call
5810
   
5811
   1 1 0 0 1 1 1
5812
   to
5813
   1 1 0 0 0 0 1 reserved
5814
5815
   1 1 0 1 0 0 0 diversion activated (used in DSS1)
5816
   1 1 0 1 0 0 1 call transfer, alerting
5817
   1 1 0 1 0 1 0 call transfer, active
5818
   
5819
   
5820
   
5821
   1 1 1 1 0 0 0
5822
   to
5823
   1 1 0 1 0 1 1
5824
   reserved
5825
   1 1 1 1 0 0 1 remote hold
5826
   1 1 1 1 0 1 0 remote retrieval
5827
   1 1 1 1 0 1 1 call is diverting
5828
   
5829
   
5830
   
5831
   1 1 1 1 1 1 1
5832
   to
5833
   1 1 1 1 1 0 0
5834
   reserved
5835
*/
5836
static const value_string q763_generic_notification_indicator_vals[] = {
5837
    { 0x00 , "User Suspended" },
5838
    { 0x01 , "User Resumed" },
5839
    { 0x02 , "Bearer service change" },
5840
    { 0x03 , "Discriminator for extension to ASN.1 encoded component (used in DSS1)" },
5841
    { 0x04 , "Call completion delay" },
5842
    { 0x42 , "Conference established" },
5843
    { 0x43 , "Conference disconnected" },
5844
    { 0x44 , "Other party added" },
5845
    { 0x45 , "Isolated" },
5846
    { 0x46 , "Reattached" },
5847
    { 0x47 , "Other party isolated" },
5848
    { 0x48 , "Other party reattached" },
5849
    { 0x49 , "Other party split" },
5850
    { 0x4A , "Other party disconnected" },
5851
    { 0x4B , "Conference floating" },
5852
    { 0x60 , "Call is a waiting call" },
5853
    { 0x68 , "Diversion activated (used in DSS1)" },
5854
    { 0x69 , "Call transfer, alerting" },
5855
    { 0x6A , "Call transfer, active" },
5856
    { 0x79 , "Remote hold" },
5857
    { 0x7A , "Remote retrieval" },
5858
    { 0x7B , "Call is diverting" },
5859
    { 0 , NULL },
5860
};
5861
static value_string_ext q763_generic_notification_indicator_vals_ext = VALUE_STRING_EXT_INIT(q763_generic_notification_indicator_vals);
5862
5863
static void
5864
dissect_isup_generic_notification_indicator_parameter(tvbuff_t *parameter_tvb, packet_info* pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
5865
37
{
5866
37
  uint8_t indicators;
5867
5868
37
  indicators = tvb_get_uint8(parameter_tvb, 0);
5869
37
  proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
5870
37
  proto_tree_add_item(parameter_tree, hf_isup_notification_indicator, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
5871
37
  proto_item_append_text(parameter_item, " : %s",
5872
37
                      val_to_str_ext(pinfo->pool, (indicators&0x7f), &q763_generic_notification_indicator_vals_ext, "Reserved (0x%X)"));
5873
37
}
5874
/* ------------------------------------------------------------------
5875
  Dissector Parameter Call history information
5876
 */
5877
static void
5878
dissect_isup_call_history_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5879
32
{
5880
32
  uint16_t info;
5881
5882
32
  info = tvb_get_ntohs(parameter_tvb, 0);
5883
32
  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);
5884
32
  proto_item_append_text(parameter_item, " : propagation delay = %u ms", info);
5885
32
}
5886
/* ------------------------------------------------------------------
5887
  Dissector Parameter Access delivery information
5888
 */
5889
static void
5890
dissect_isup_access_delivery_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5891
23
{
5892
23
  uint8_t indicator;
5893
5894
23
  indicator = tvb_get_uint8(parameter_tvb, 0);
5895
23
  proto_tree_add_boolean(parameter_tree, hf_isup_access_delivery_ind, parameter_tvb, 0, ACCESS_DELIVERY_INFO_LENGTH, indicator);
5896
23
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
5897
23
}
5898
/* ------------------------------------------------------------------
5899
  Dissector Parameter Network specific facility
5900
 */
5901
static void
5902
dissect_isup_network_specific_facility_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5903
26
{ unsigned length = tvb_reported_length(parameter_tvb);
5904
26
  proto_tree_add_item(parameter_tree, hf_isup_network_specific_facility, parameter_tvb, 0, length, ENC_NA);
5905
26
}
5906
/* ------------------------------------------------------------------
5907
  Dissector Parameter User service information prime
5908
 */
5909
static void
5910
dissect_isup_user_service_information_prime_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5911
47
{ unsigned length = tvb_reported_length(parameter_tvb);
5912
47
  proto_tree_add_item(parameter_tree, hf_isup_user_service_information_prime, parameter_tvb, 0, length, ENC_NA);
5913
47
  dissect_q931_bearer_capability_ie(parameter_tvb,
5914
47
                                    0, length,
5915
47
                                    parameter_tree);
5916
47
}
5917
/* ------------------------------------------------------------------
5918
  Dissector Parameter Propagation delay counter
5919
 */
5920
static void
5921
dissect_isup_propagation_delay_counter_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5922
36
{
5923
36
  uint32_t info;
5924
5925
36
  proto_tree_add_item_ret_uint(parameter_tree, hf_isup_propagation_delay_counter, parameter_tvb, 0, PROPAGATION_DELAY_COUNT_LENGTH, ENC_BIG_ENDIAN, &info);
5926
36
  proto_item_append_text(parameter_item, ": counter = %u ms", info);
5927
36
}
5928
/* ------------------------------------------------------------------
5929
  Dissector Parameter Remote operations
5930
 */
5931
static void
5932
dissect_isup_remote_operations_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5933
28
{ unsigned length = tvb_reported_length(parameter_tvb);
5934
28
  proto_tree_add_item(parameter_tree, hf_isup_remote_operations, parameter_tvb, 0, length, ENC_NA);
5935
28
}
5936
/* ------------------------------------------------------------------
5937
  Dissector Parameter Service activation
5938
 */
5939
static void
5940
dissect_isup_service_activation_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5941
54
{
5942
54
  unsigned  i;
5943
54
  uint8_t feature_code;
5944
54
  unsigned  length = tvb_reported_length(parameter_tvb);
5945
5946
2.65k
  for (i=0; i<length; i++) {
5947
2.59k
    feature_code = tvb_get_uint8(parameter_tvb, i);
5948
2.59k
    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);
5949
2.59k
  }
5950
54
}
5951
/* ------------------------------------------------------------------
5952
  Dissector Parameter User service information prime - no detailed dissection since defined in Rec. Q.931
5953
 */
5954
static void
5955
dissect_isup_user_teleservice_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
5956
29
{
5957
29
  unsigned length = tvb_reported_length(parameter_tvb);
5958
29
  proto_tree_add_item(parameter_tree, hf_isup_user_teleservice_information, parameter_tvb, 0, length, ENC_NA);
5959
5960
29
  dissect_q931_high_layer_compat_ie(parameter_tvb, 0, length, parameter_tree);
5961
29
}
5962
/* ------------------------------------------------------------------
5963
  Dissector Parameter Transmission medium requirement used
5964
 */
5965
static void
5966
dissect_isup_transmission_medium_used_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5967
63
{
5968
63
  uint8_t transmission_medium_requirement;
5969
5970
63
  transmission_medium_requirement = tvb_get_uint8(parameter_tvb, 0);
5971
63
  proto_tree_add_uint(parameter_tree, hf_isup_transmission_medium_requirement_prime,
5972
63
                      parameter_tvb, 0, TRANSMISSION_MEDIUM_RQMT_PRIME_LENGTH, transmission_medium_requirement);
5973
5974
63
  proto_item_append_text(parameter_item,
5975
63
                      " : %u (%s)",
5976
63
                      transmission_medium_requirement,
5977
63
                      val_to_str_ext_const(transmission_medium_requirement,
5978
63
                                           &isup_transmission_medium_requirement_prime_value_ext,
5979
63
                                           "spare/reserved"));
5980
63
}
5981
/* ------------------------------------------------------------------
5982
  Dissector Parameter Call diversion information
5983
 */
5984
static void
5985
dissect_isup_call_diversion_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
5986
15
{ uint8_t indicator;
5987
5988
15
  indicator = tvb_get_uint8(parameter_tvb, 0);
5989
15
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_call_diversion_information, parameter_tvb, 0, CALL_DIV_INFO_LENGTH, indicator,
5990
15
        "0x%x (refer to 3.6/Q.763 for detailed decoding)", indicator);
5991
15
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
5992
15
}
5993
/* ------------------------------------------------------------------
5994
  Dissector Parameter Echo control  information
5995
 */
5996
static const value_string OECD_inf_ind_vals[] = {
5997
  {0x00, "no information"},
5998
  {0x01, "outgoing echo control device not included and not available"},
5999
  {0x02, "outgoing echo control device included"},
6000
  {0x03, "outgoing echo control device not included but available"},
6001
  { 0,  NULL }
6002
};
6003
static const value_string IECD_inf_ind_vals[] = {
6004
  {0x00, "no information"},
6005
  {0x01, "incoming echo control device not included and not available"},
6006
  {0x02, "incoming echo control device included"},
6007
  {0x03, "incoming echo control device not included but available"},
6008
  { 0,  NULL }
6009
};
6010
6011
static const value_string OECD_req_ind_vals[] = {
6012
  {0x00, "no information"},
6013
  {0x01, "outgoing echo control device activation request"},
6014
  {0x02, "outgoing echo control device deactivation request"},
6015
  {0x03, "spare"},
6016
  { 0,  NULL }
6017
};
6018
6019
static const value_string IECD_req_ind_vals[] = {
6020
  {0x00, "no information"},
6021
  {0x01, "incoming echo control device activation request"},
6022
  {0x02, "incoming echo control device deactivation request"},
6023
  {0x03, "spare"},
6024
  { 0,  NULL }
6025
};
6026
6027
static void
6028
dissect_isup_echo_control_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6029
23
{ uint8_t indicator;
6030
23
  static int * const info[] = {
6031
23
    &hf_isup_OECD_inf_ind,
6032
23
    &hf_isup_IECD_inf_ind,
6033
23
    &hf_isup_OECD_req_ind,
6034
23
    &hf_isup_IECD_req_ind,
6035
23
    NULL
6036
23
  };
6037
6038
23
  indicator = tvb_get_uint8(parameter_tvb, 0);
6039
23
  proto_tree_add_bitmask(parameter_tree, parameter_tvb, 0, hf_isup_echo_control_information, ett_echo_control_information, info, ENC_NA);
6040
6041
23
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
6042
23
}
6043
/* ------------------------------------------------------------------
6044
  Dissector Parameter Message compatibility information
6045
 */
6046
6047
static const true_false_string isup_pass_on_not_possible_indicator_value = {
6048
  "discard information",
6049
  "release call",
6050
};
6051
6052
static void
6053
dissect_isup_message_compatibility_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6054
9
{
6055
9
  int   offset = 0;
6056
6057
9
  static int * const params[] = {
6058
9
    &hf_isup_transit_at_intermediate_exchange_ind,
6059
9
    &hf_isup_Release_call_ind,
6060
9
    &hf_isup_Send_notification_ind,
6061
9
    &hf_isup_Discard_message_ind_value,
6062
9
    &hf_isup_pass_on_not_possible_indicator2,
6063
9
    &hf_isup_Broadband_narrowband_interworking_ind2,
6064
9
    &hf_isup_extension_ind,
6065
9
    NULL
6066
9
  };
6067
6068
9
  proto_tree_add_bitmask(parameter_tree, parameter_tvb, offset, hf_isup_message_compatibility_information, ett_message_compatibility_information, params, ENC_NA);
6069
9
}
6070
/* ------------------------------------------------------------------
6071
  Dissector Parameter compatibility information
6072
 */
6073
static const true_false_string isup_transit_at_intermediate_exchange_ind_value  = {
6074
  "End node interpretation",
6075
  "Transit interpretation"
6076
};
6077
6078
6079
static const true_false_string isup_Discard_message_ind_value = {
6080
  "Discard message",
6081
  "Do not discard message (pass on)",
6082
};
6083
6084
static const true_false_string isup_Discard_parameter_ind_value = {
6085
  "Discard parameter",
6086
  "Do not discard parameter (pass on)",
6087
};
6088
6089
static const value_string isup_Pass_on_not_possible_indicator_vals[] = {
6090
  { 0x00, "Release call" },
6091
  { 0x01, "Discard message" },
6092
  { 0x02, "Discard parameter" },
6093
  { 0x03, "Reserved (interpreted as 00)" },
6094
  { 0, NULL },
6095
};
6096
static const value_string ISUP_Broadband_narrowband_interworking_indicator_vals[] = {
6097
  { 0x00, "Pass on" },
6098
  { 0x01, "Discard message" },
6099
  { 0x02, "Release call" },
6100
  { 0x03, "Discard parameter" },
6101
  { 0, NULL },
6102
};
6103
6104
static void
6105
dissect_isup_parameter_compatibility_information_parameter(tvbuff_t *parameter_tvb, packet_info* pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6106
43
{
6107
43
  unsigned  length = tvb_reported_length(parameter_tvb);
6108
43
  unsigned  len    = length;
6109
43
  uint8_t upgraded_parameter, upgraded_parameter_no;
6110
43
  int    offset;
6111
43
  uint8_t instruction_indicators;
6112
6113
43
  static int * const indicator_flags[] = {
6114
43
    &hf_isup_transit_at_intermediate_exchange_ind,
6115
43
    &hf_isup_Release_call_ind,
6116
43
    &hf_isup_Send_notification_ind,
6117
43
    &hf_isup_Discard_message_ind_value,
6118
43
    &hf_isup_Discard_parameter_ind,
6119
43
    &hf_isup_Pass_on_not_possible_indicator,
6120
43
    &hf_isup_extension_ind,
6121
43
    NULL
6122
43
  };
6123
6124
43
  offset = 0;
6125
43
  upgraded_parameter_no = 0;
6126
6127
/* etxrab Decoded as per Q.763 section 3.41 */
6128
6129
936
  while (len > 0) {
6130
930
    upgraded_parameter_no = upgraded_parameter_no + 1;
6131
930
    upgraded_parameter = tvb_get_uint8(parameter_tvb, offset);
6132
6133
930
    proto_tree_add_uint_format(parameter_tree, hf_isup_upgraded_parameter, parameter_tvb, offset, 1, upgraded_parameter,
6134
930
                              "Upgraded parameter no: %u = %s", upgraded_parameter_no,
6135
930
                              val_to_str_ext(pinfo->pool, upgraded_parameter, &isup_parameter_type_value_ext, "unknown (%u)"));
6136
930
    offset += 1;
6137
930
    len -= 1;
6138
930
    instruction_indicators = tvb_get_uint8(parameter_tvb, offset);
6139
930
    proto_tree_add_bitmask(parameter_tree, parameter_tvb, offset, hf_isup_instruction_indicators, ett_instruction_indicators, indicator_flags, ENC_NA);
6140
6141
930
    offset += 1;
6142
930
    len -= 1;
6143
930
    if (!(instruction_indicators & H_8BIT_MASK)) {
6144
639
      if (len == 0)
6145
13
        return;
6146
626
      instruction_indicators = tvb_get_uint8(parameter_tvb, offset);
6147
626
      proto_tree_add_uint(parameter_tree, hf_isup_Broadband_narrowband_interworking_ind,
6148
626
                          parameter_tvb, offset, 1, instruction_indicators);
6149
626
      offset += 1;
6150
626
      len -= 1;
6151
626
    }
6152
6153
917
    if (len == 0)
6154
24
      return;
6155
917
  }
6156
43
}
6157
/* ------------------------------------------------------------------
6158
  Dissector Parameter MLPP precedence
6159
 */
6160
static const value_string isup_mlpp_precedence_look_forward_busy_vals[] = {
6161
    { 0x00 , "Allowed" },
6162
    { 0x01 , "Not Allowed" },
6163
    { 0x02 , "Path reserved" },
6164
    { 0x03 , "Spare" },
6165
    { 0 , NULL },
6166
};
6167
6168
static const value_string isup_mlpp_precedence_level_vals[] = {
6169
    { 0x00 , "Flash Override" },
6170
    { 0x01 , "Flash" },
6171
    { 0x02 , "Immediate" },
6172
    { 0x03 , "Priority" },
6173
    { 0x04 , "Routine" },
6174
    { 0x05 , "Spare" },
6175
    { 0x06 , "Spare" },
6176
    { 0x07 , "Spare" },
6177
    { 0x08 , "Spare" },
6178
    { 0x09 , "Spare" },
6179
    { 0x0A , "Spare" },
6180
    { 0x0B , "Spare" },
6181
    { 0x0C , "Spare" },
6182
    { 0x0D , "Spare" },
6183
    { 0x0E , "Spare" },
6184
    { 0x0F , "Spare" },
6185
    { 0 , NULL },
6186
};
6187
6188
static void
6189
dissect_isup_mlpp_precedence_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6190
89
{
6191
89
  char        NI_digits[5] = "";
6192
89
  const char *temp_text = "";
6193
89
  uint8_t     digit_pair;
6194
89
  uint32_t    bin_code;
6195
6196
89
  proto_tree_add_item(parameter_tree, hf_isup_look_forward_busy, parameter_tvb, 0, 1, ENC_NA);
6197
6198
89
  proto_tree_add_item(parameter_tree, hf_isup_precedence_level, parameter_tvb, 0, 1, ENC_NA);
6199
6200
89
  digit_pair   = tvb_get_uint8(parameter_tvb, 1);
6201
89
  NI_digits[0] = number_to_char((digit_pair & HGFE_8BIT_MASK) / 0x10);
6202
89
  NI_digits[1] = number_to_char(digit_pair & DCBA_8BIT_MASK);
6203
89
  digit_pair   = tvb_get_uint8(parameter_tvb, 2);
6204
89
  NI_digits[2] = number_to_char((digit_pair & HGFE_8BIT_MASK) / 0x10);
6205
89
  NI_digits[3] = number_to_char(digit_pair & DCBA_8BIT_MASK);
6206
89
  NI_digits[4] = '\0';
6207
89
  proto_tree_add_string(parameter_tree, hf_isup_network_identity, parameter_tvb, 1, 2, NI_digits);
6208
89
  bin_code = tvb_get_ntoh24(parameter_tvb, 3);
6209
89
  proto_tree_add_item(parameter_tree, hf_isup_mlpp_service_domain, parameter_tvb, 3, 3, ENC_BIG_ENDIAN);
6210
89
  proto_item_append_text(parameter_item,
6211
89
                      " : Prec = %s, NI = %s, MLPP service domain = 0x%x", temp_text, NI_digits, bin_code);
6212
89
}
6213
/* ------------------------------------------------------------------
6214
  Dissector Parameter MCID request indicators
6215
 */
6216
static void
6217
dissect_isup_mcid_request_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6218
14
{ uint8_t indicator;
6219
6220
14
  indicator = tvb_get_uint8(parameter_tvb, 0);
6221
14
  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);
6222
14
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
6223
14
}
6224
/* ------------------------------------------------------------------
6225
  Dissector Parameter MCID response indicators
6226
 */
6227
static void
6228
dissect_isup_mcid_response_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6229
22
{ uint8_t indicator;
6230
6231
22
  indicator = tvb_get_uint8(parameter_tvb, 0);
6232
22
  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);
6233
22
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
6234
22
}
6235
/* ------------------------------------------------------------------
6236
  Dissector Parameter Hop counter
6237
 */
6238
static void
6239
dissect_isup_hop_counter_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6240
16
{ uint8_t counter;
6241
6242
  /* N.B., bits H,G and F are spare */
6243
16
  proto_tree_add_item_ret_uint8(parameter_tree, hf_isup_hop_counter, parameter_tvb, 0, HOP_COUNTER_LENGTH, ENC_NA, &counter);
6244
16
  proto_item_append_text(parameter_item, " : %u", counter);
6245
16
}
6246
/* ------------------------------------------------------------------
6247
  Dissector Parameter Originating line information
6248
 */
6249
static void
6250
dissect_isup_orig_line_info_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6251
0
{ uint8_t info;
6252
6253
0
  proto_tree_add_item_ret_uint8(parameter_tree, hf_isup_originating_line_info, parameter_tvb, 0, ORIG_LINE_INFO_LENGTH, ENC_NA, &info);
6254
0
  proto_item_append_text(parameter_item,  " : %u (ANI II if < 51, reserved otherwise)", info);
6255
0
}
6256
/* ------------------------------------------------------------------
6257
  Dissector Parameter Transmission medium requirement prime
6258
 */
6259
static void
6260
dissect_isup_transmission_medium_requirement_prime_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6261
32
{
6262
32
  uint8_t transmission_medium_requirement;
6263
6264
32
  transmission_medium_requirement = tvb_get_uint8(parameter_tvb, 0);
6265
32
  proto_tree_add_uint(parameter_tree, hf_isup_transmission_medium_requirement_prime,
6266
32
                      parameter_tvb, 0, TRANSMISSION_MEDIUM_RQMT_PRIME_LENGTH, transmission_medium_requirement);
6267
6268
32
  proto_item_append_text(parameter_item,
6269
32
                      " : %u (%s)",
6270
32
                      transmission_medium_requirement,
6271
32
                      val_to_str_ext_const(transmission_medium_requirement,
6272
32
                                           &isup_transmission_medium_requirement_prime_value_ext,
6273
32
                                           "spare/reserved"));
6274
32
}
6275
6276
/* ------------------------------------------------------------------
6277
  Dissector Parameter location number
6278
 */
6279
void
6280
dissect_isup_location_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
6281
35
{
6282
35
  uint8_t     indicators1, indicators2;
6283
35
  int         offset = 0;
6284
35
  static int * const indicators1_fields[] = {
6285
35
    &hf_isup_odd_even_indicator,
6286
35
    &hf_isup_calling_party_nature_of_address_indicator,
6287
35
    NULL
6288
35
  };
6289
6290
35
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
6291
35
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
6292
35
  indicators2 = tvb_get_uint8(parameter_tvb, 1);
6293
35
  proto_tree_add_boolean(parameter_tree, hf_isup_inn_indicator, parameter_tvb, 1, 1, indicators2);
6294
35
  proto_tree_add_uint(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, 1, 1, indicators2);
6295
35
  if ((indicators2 & GFE_8BIT_MASK) == 0x50) {
6296
1
    proto_tree_add_uint_format_value(parameter_tree, hf_isup_number_different_meaning, parameter_tvb, 1, 1, indicators2 & GFE_8BIT_MASK,
6297
1
                                     "Numbering plan indicator = private numbering plan");
6298
1
  }
6299
35
  proto_tree_add_uint(parameter_tree, hf_isup_address_presentation_restricted_indicator, parameter_tvb, 1, 1, indicators2);
6300
35
  proto_tree_add_uint(parameter_tree, hf_isup_screening_indicator, parameter_tvb, 1, 1, indicators2);
6301
6302
   /* NOTE  When the address presentation restricted indicator indicates address not available, the
6303
    * subfields in items a), b), c) and d) are coded with 0's, and the screening indicator is set to 11
6304
    * (network provided).
6305
    * BUG 938 - Just check if there is someting more to dissect.
6306
    */
6307
35
  if (tvb_reported_length_remaining(parameter_tvb, offset) < 3) {
6308
1
    proto_item_append_text(parameter_item, " : address not available");
6309
1
    return;
6310
1
  }
6311
6312
34
  offset = 2;
6313
6314
34
  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
6315
34
                             hf_isup_location_number, hf_isup_calling_party_odd_address_signal_digit,
6316
34
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
6317
34
                             NONE, 0);
6318
34
}
6319
6320
/* ------------------------------------------------------------------
6321
  Dissector Parameter Redirection number restriction
6322
 */
6323
static const value_string isup_redirection_presentation_indicator_vals[] = {
6324
    { 0x00 , "Presentation allowed" },
6325
    { 0x01 , "Presentation restricted" },
6326
    { 0x02 , "Spare" },
6327
    { 0x03 , "Spare" },
6328
    { 0 , NULL },
6329
};
6330
6331
static void
6332
dissect_isup_redirection_number_restriction_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6333
12
{
6334
12
  uint8_t indicator;
6335
6336
12
  proto_tree_add_item_ret_uint8(parameter_tree, hf_isup_presentation_indicator, parameter_tvb, 0, REDIRECTION_NUMBER_RESTRICTION_LENGTH, ENC_NA, &indicator);
6337
12
  proto_item_append_text(parameter_item, " : 0x%x ", indicator);
6338
12
}
6339
/* ------------------------------------------------------------------
6340
  Dissector Parameter Call transfer identity
6341
 */
6342
static void
6343
dissect_isup_call_transfer_reference_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6344
15
{ uint8_t id;
6345
6346
15
  id = tvb_get_uint8(parameter_tvb, 0);
6347
15
  proto_tree_add_item(parameter_tree, hf_isup_call_transfer_identity, parameter_tvb, 0, CALL_TRANSFER_REF_LENGTH, ENC_NA);
6348
15
  proto_item_append_text(parameter_item,  " : %u", id);
6349
15
}
6350
/* ------------------------------------------------------------------
6351
  Dissector Parameter Loop prevention
6352
 */
6353
6354
static void
6355
dissect_isup_loop_prevention_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6356
8
{
6357
8
  uint8_t indicator;
6358
6359
8
  indicator = tvb_get_uint8(parameter_tvb, 0);
6360
8
  proto_tree_add_item(parameter_tree, hf_isup_loop_prevention_indicator_type, parameter_tvb, 0, LOOP_PREVENTION_IND_LENGTH, ENC_NA);
6361
8
  if ((indicator & A_8BIT_MASK) == 0) {
6362
6
    proto_item_append_text(parameter_item, " : Request (%u)", indicator);
6363
6
  }
6364
2
  else {
6365
2
    proto_tree_add_uint(parameter_tree, hf_isup_loop_prevention_response_ind,
6366
2
                        parameter_tvb, 0, LOOP_PREVENTION_IND_LENGTH, indicator);
6367
2
    proto_item_append_text(parameter_item, " : Response (%u)", indicator);
6368
2
  }
6369
8
}
6370
6371
/* ------------------------------------------------------------------
6372
  Dissector Parameter Call transfer number
6373
 */
6374
static void
6375
dissect_isup_call_transfer_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
6376
22
{
6377
22
  uint8_t     indicators1, indicators2;
6378
22
  int         offset = 0;
6379
6380
22
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
6381
22
  proto_tree_add_boolean(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, indicators1);
6382
22
  proto_tree_add_uint(parameter_tree, hf_isup_calling_party_nature_of_address_indicator, parameter_tvb, 0, 1, indicators1);
6383
22
  indicators2 = tvb_get_uint8(parameter_tvb, 1);
6384
22
  proto_tree_add_uint(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, 1, 1, indicators2);
6385
22
  if ((indicators2 & GFE_8BIT_MASK) == 0x50)
6386
3
    proto_tree_add_uint_format_value(parameter_tree, hf_isup_number_different_meaning, parameter_tvb, 1, 1, indicators2 & GFE_8BIT_MASK,
6387
3
                    "Numbering plan indicator = private numbering plan");
6388
22
  proto_tree_add_uint(parameter_tree, hf_isup_address_presentation_restricted_indicator, parameter_tvb, 1, 1, indicators2);
6389
22
  proto_tree_add_uint(parameter_tree, hf_isup_screening_indicator_enhanced, parameter_tvb, 1, 1, indicators2);
6390
22
  offset = 2;
6391
6392
22
  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
6393
22
                             hf_isup_call_transfer_number, hf_isup_calling_party_odd_address_signal_digit,
6394
22
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
6395
22
                             NONE, 0);
6396
22
}
6397
6398
/* ------------------------------------------------------------------
6399
  Dissector Parameter CCSS
6400
 */
6401
static const true_false_string tfs_ccss_call_no_indication = { "CCSS call", "no indication"};
6402
6403
static void
6404
dissect_isup_ccss_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6405
16
{
6406
16
  uint8_t indicator;
6407
6408
16
  indicator = tvb_get_uint8(parameter_tvb, 0);
6409
16
  proto_tree_add_item(parameter_tree, hf_isup_ccss_call_indicator, parameter_tvb, 0, LOOP_PREVENTION_IND_LENGTH, ENC_NA);
6410
16
  if ((indicator & A_8BIT_MASK) == 0) {
6411
2
    proto_item_append_text(parameter_item, " : no indication (%u)", indicator);
6412
2
  }
6413
14
  else {
6414
14
    proto_item_append_text(parameter_item, " : CCSS call (%u)", indicator);
6415
14
  }
6416
16
}
6417
/* ------------------------------------------------------------------
6418
 Parameter Forward GVNS
6419
 */
6420
static void
6421
dissect_isup_forward_gvns_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6422
8
{ unsigned length = tvb_reported_length(parameter_tvb);
6423
8
  proto_tree_add_item(parameter_tree, hf_isup_forward_gvns, parameter_tvb, 0, length, ENC_NA);
6424
8
}
6425
/* ------------------------------------------------------------------
6426
 Parameter Redirect capability
6427
 */
6428
6429
static const value_string isup_jpn_redirect_capabilit_vals[] = {
6430
  { 0,   "Reserved" },
6431
  { 1,   "Redirect possible before ACM" },
6432
  { 2,   "Reserved" },
6433
  { 3,   "Reserved" },
6434
  { 4,   "Spare" },
6435
  { 5,   "Spare" },
6436
  { 6,   "Spare" },
6437
  { 7,   "Spare" },
6438
  { 0,   NULL}
6439
};
6440
6441
static void
6442
dissect_isup_redirect_capability_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_, uint8_t itu_isup_variant)
6443
10
{
6444
10
  unsigned length = tvb_reported_length(parameter_tvb);
6445
6446
10
  switch (itu_isup_variant) {
6447
0
    case ISUP_JAPAN_VARIANT:
6448
    /* Fall through */
6449
0
    case ISUP_JAPAN_TTC_VARIANT:
6450
0
      proto_tree_add_item(parameter_tree, hf_isup_extension_ind,             parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
6451
0
      proto_tree_add_item(parameter_tree, hf_japan_isup_redirect_capability, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
6452
0
      break;
6453
10
    default:
6454
10
      proto_tree_add_uint_format_value(parameter_tree, hf_isup_redirect_capability, parameter_tvb, 0, length, itu_isup_variant, "(format is a national matter)");
6455
10
      break;
6456
10
  }
6457
10
}
6458
/* ------------------------------------------------------------------
6459
  Dissector Parameter Backward GVNS
6460
 */
6461
static void
6462
dissect_isup_backward_gvns_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6463
13
{ uint8_t indicator;
6464
6465
13
  indicator = tvb_get_uint8(parameter_tvb, 0);
6466
13
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_backward_gvns, parameter_tvb, 0, BACKWARD_GVNS_LENGTH, indicator,
6467
13
                    "0x%x (refer to 3.62/Q.763 for detailed decoding)", indicator);
6468
13
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
6469
13
}
6470
/* ------------------------------------------------------------------
6471
  Dissector Parameter Network management controls
6472
 */
6473
static void
6474
dissect_isup_network_management_controls_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6475
30
{ uint8_t indicator;
6476
6477
30
  indicator = tvb_get_uint8(parameter_tvb, 0);
6478
30
  proto_tree_add_boolean(parameter_tree, hf_isup_temporary_alternative_routing_ind,
6479
30
                         parameter_tvb, 0, NETWORK_MANAGEMENT_CONTROLS_LENGTH, indicator);
6480
30
  proto_tree_add_boolean(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, NETWORK_MANAGEMENT_CONTROLS_LENGTH, indicator);
6481
30
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
6482
30
}
6483
/* ------------------------------------------------------------------
6484
  Dissector Parameter Correlation id - no detailed dissection since defined in Rec. Q.1281
6485
 */
6486
static void
6487
dissect_isup_correlation_id_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6488
12
{ unsigned length = tvb_reported_length(parameter_tvb);
6489
12
  proto_tree_add_item(parameter_tree, hf_isup_correlation_id, parameter_tvb, 0, length, ENC_NA);
6490
12
}
6491
/* ------------------------------------------------------------------
6492
  Dissector Parameter SCF id - no detailed dissection since defined in Rec. Q.1281
6493
 */
6494
static void
6495
dissect_isup_scf_id_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6496
16
{ unsigned length = tvb_reported_length(parameter_tvb);
6497
16
  proto_tree_add_item(parameter_tree, hf_isup_scf_id, parameter_tvb, 0, length, ENC_NA);
6498
16
}
6499
/* ------------------------------------------------------------------
6500
  Dissector Parameter Call diversion treatment indicators
6501
 */
6502
static void
6503
dissect_isup_call_diversion_treatment_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6504
20
{ uint8_t indicator;
6505
6506
20
  indicator = tvb_get_uint8(parameter_tvb, 0);
6507
20
  proto_tree_add_uint(parameter_tree, hf_isup_call_to_be_diverted_ind, parameter_tvb, 0, CALL_DIV_TREATMENT_IND_LENGTH, indicator);
6508
20
  proto_tree_add_boolean(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, CALL_DIV_TREATMENT_IND_LENGTH, indicator);
6509
20
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
6510
20
}
6511
6512
/* ------------------------------------------------------------------
6513
  Dissector Parameter called IN  number
6514
 */
6515
static void
6516
dissect_isup_called_in_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
6517
11
{
6518
11
  uint8_t     indicators1;
6519
11
  int         offset = 0;
6520
11
  static int * const indicators1_fields[] = {
6521
11
    &hf_isup_odd_even_indicator,
6522
11
    &hf_isup_calling_party_nature_of_address_indicator,
6523
11
    NULL
6524
11
  };
6525
11
  static int * const indicators2_fields[] = {
6526
11
    &hf_isup_numbering_plan_indicator,
6527
11
    &hf_isup_address_presentation_restricted_indicator,
6528
11
    NULL
6529
11
  };
6530
6531
11
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
6532
11
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
6533
11
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 1, 1, indicators2_fields, ENC_NA);
6534
11
  offset = 2;
6535
6536
11
  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
6537
11
                             hf_isup_called_in_number, hf_isup_calling_party_odd_address_signal_digit,
6538
11
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
6539
11
                             NONE, 0);
6540
11
}
6541
6542
/* ------------------------------------------------------------------
6543
  Dissector Parameter Call offering treatment indicators
6544
 */
6545
static void
6546
dissect_isup_call_offering_treatment_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6547
16
{ uint8_t indicator;
6548
6549
16
  indicator = tvb_get_uint8(parameter_tvb, 0);
6550
16
  proto_tree_add_uint(parameter_tree, hf_isup_call_to_be_offered_ind, parameter_tvb, 0, CALL_OFFERING_TREATMENT_IND_LENGTH, indicator);
6551
16
  proto_tree_add_boolean(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, CALL_OFFERING_TREATMENT_IND_LENGTH, indicator);
6552
16
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
6553
16
}
6554
/* ------------------------------------------------------------------
6555
 Parameter Charged party identification
6556
 */
6557
static void
6558
dissect_isup_charged_party_identification_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6559
8
{ unsigned length = tvb_reported_length(parameter_tvb);
6560
8
  proto_tree_add_item(parameter_tree, hf_isup_charged_party_identification, parameter_tvb, 0, length, ENC_NA);
6561
8
}
6562
/* ------------------------------------------------------------------
6563
  Dissector Parameter Conference treatment indicators
6564
 */
6565
static void
6566
dissect_isup_conference_treatment_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6567
14
{ uint8_t indicator;
6568
6569
14
  indicator = tvb_get_uint8(parameter_tvb, 0);
6570
14
  proto_tree_add_uint(parameter_tree, hf_isup_conference_acceptance_ind, parameter_tvb, 0, CONFERENCE_TREATMENT_IND_LENGTH, indicator);
6571
14
  proto_tree_add_boolean(parameter_tree, hf_isup_extension_ind, parameter_tvb, 0, CONFERENCE_TREATMENT_IND_LENGTH, indicator);
6572
14
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
6573
14
}
6574
/* ------------------------------------------------------------------
6575
  Dissector Parameter Display information
6576
 * TODO Output Display info :
6577
 * Quote from Q.931:
6578
 * 4.5.16 Display
6579
 * The purpose of the Display information element is to supply display information
6580
 * that may be displayed by the user. The information contained in this element is coded
6581
 * in IA5 characters.
6582
 * 8 7 6 5 4 3 2 1   Octet
6583
 * 0 0 1 0 1 0 0 0   1      Display information element identifier
6584
 *                   2      Length of display contents
6585
 * 0                 3      Display information (IA5 characters)
6586
 * etc.
6587
 * - end - quote -
6588
 * Assuming octet 2 and onwards is passed here - just output text ?
6589
 */
6590
static void
6591
dissect_isup_display_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6592
12
{ unsigned length = tvb_reported_length(parameter_tvb);
6593
12
  proto_tree_add_item(parameter_tree, hf_isup_display_information, parameter_tvb, 0, length, ENC_NA);
6594
12
}
6595
/* ------------------------------------------------------------------
6596
 Parameter UID action indicators
6597
 */
6598
static void
6599
dissect_isup_uid_action_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6600
18
{ uint8_t indicator;
6601
6602
18
  indicator = tvb_get_uint8(parameter_tvb, 0);
6603
18
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_uid_action_indicators, parameter_tvb, 0, UID_ACTION_IND_LENGTH, indicator,
6604
18
        "0x%x (refer to 3.78/Q.763 for detailed decoding)", indicator);
6605
18
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
6606
18
}
6607
/* ------------------------------------------------------------------
6608
 Parameter UID capability indicators
6609
 */
6610
static void
6611
dissect_isup_uid_capability_indicators_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6612
8
{ uint8_t indicator;
6613
6614
8
  indicator = tvb_get_uint8(parameter_tvb, 0);
6615
8
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_uid_capability_indicators, parameter_tvb, 0, UID_CAPABILITY_IND_LENGTH,
6616
8
                      indicator, "0x%x (refer to 3.79/Q.763 for detailed decoding)", indicator);
6617
8
  proto_item_append_text(parameter_item, " : 0x%x", indicator);
6618
8
}
6619
/* ------------------------------------------------------------------
6620
 Parameter Redirect counter
6621
 */
6622
static void
6623
dissect_isup_redirect_counter_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_, uint8_t itu_isup_variant)
6624
8
{
6625
8
  unsigned length = tvb_reported_length(parameter_tvb);
6626
6627
8
  switch (itu_isup_variant) {
6628
0
    case ISUP_JAPAN_VARIANT:
6629
    /* Fall through */
6630
0
    case ISUP_JAPAN_TTC_VARIANT:
6631
0
      proto_tree_add_item(parameter_tree, hf_japan_isup_redirect_counter, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
6632
0
      break;
6633
8
    default:
6634
8
      proto_tree_add_uint_format_value(parameter_tree, hf_isup_redirect_counter, parameter_tvb, 0, length, itu_isup_variant, "(format is a national matter)");
6635
8
      break;
6636
8
  }
6637
8
}
6638
/* ------------------------------------------------------------------
6639
  Dissector Parameter Collect call request
6640
 */
6641
static const true_false_string tfs_collect_call_req_no_indication = { "collect call requested", "no indication"};
6642
6643
static void
6644
dissect_isup_collect_call_request_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
6645
13
{ uint8_t indicator;
6646
6647
13
  indicator = tvb_get_uint8(parameter_tvb, 0);
6648
13
  proto_tree_add_item(parameter_tree, hf_isup_collect_call_request_indicator, parameter_tvb, 0, COLLECT_CALL_REQUEST_LENGTH, ENC_NA);
6649
13
  if ((indicator & A_8BIT_MASK) == 0) {
6650
4
    proto_item_append_text(parameter_item, " : no indication (0x%x)", indicator);
6651
4
  }
6652
9
  else {
6653
9
    proto_item_append_text(parameter_item, " : collect call requested (0x%x)", indicator);
6654
9
  }
6655
13
}
6656
/* ------------------------------------------------------------------
6657
  Dissector Parameter Calling geodetic location
6658
 */
6659
void
6660
dissect_isup_calling_geodetic_location_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6661
2
{
6662
2
  unsigned  length = tvb_reported_length(parameter_tvb);
6663
2
  uint8_t oct, lpri;
6664
6665
2
  oct = tvb_get_uint8(parameter_tvb, 0);
6666
2
  lpri = (oct & 0xc0) >> 2;
6667
6668
2
  proto_tree_add_uint(parameter_tree, hf_isup_geo_loc_presentation_restricted_ind, parameter_tvb, 0, 1, oct);
6669
2
  proto_tree_add_uint(parameter_tree, hf_isup_geo_loc_screening_ind, parameter_tvb, 0, 1, oct);
6670
6671
2
  proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, 1, 1, ENC_NA);
6672
2
  proto_tree_add_item(parameter_tree, hf_isup_geo_loc_shape, parameter_tvb, 1, 1, ENC_NA);
6673
6674
2
  if (length > 2)
6675
2
  {
6676
2
    if (lpri < 0x2)
6677
1
    {
6678
1
      proto_tree_add_item(parameter_tree, hf_isup_geo_loc_shape_description, parameter_tvb, 2, length - 2, ENC_NA);
6679
1
    }
6680
1
    else
6681
1
    {
6682
      /* not supposed to have any data if 'lpri' was 'location not available' */
6683
6684
1
      proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, 2, length - 2,
6685
1
                "Unknown (?), should not have data if LPRI is 'location not available'");
6686
1
    }
6687
2
  }
6688
2
}
6689
6690
/* ------------------------------------------------------------------
6691
  Dissector Parameter Generic number
6692
 */
6693
static const range_string number_qualifier_indicator_vals[] = {
6694
  { 0x00, 0x00, "reserved (dialled digits) (national use)"},
6695
  { 0x01, 0x01, "additional called number (national use)"},
6696
  { 0x02, 0x02, "reserved (supplemental user provided calling number - failed network screening) (national use)"},
6697
  { 0x03, 0x03, "reserved (supplemental user provided calling number - not screened) (national use)"},
6698
  { 0x04, 0x04, "reserved (redirecting terminating number) (national use)"},
6699
  { 0x05, 0x05, "additional connected number"},
6700
  { 0x06, 0x06, "additional calling party number"},
6701
  { 0x07, 0x07, "reserved for additional original called number"},
6702
  { 0x08, 0x08, "reserved for additional redirecting number"},
6703
  { 0x09, 0x09, "reserved for additional redirection number"},
6704
  { 0x0a, 0x0a, "reserved (used in 1992 version)"},
6705
  { 0x0b, 0x7f, "spare"},
6706
  { 0x80, 0xfe, "reserved for national use"},
6707
  { 0xff, 0xff, "reserved for expansion"},
6708
  { 0, 0, NULL}
6709
};
6710
void
6711
dissect_isup_generic_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
6712
35
{
6713
35
  uint8_t     indicators1, indicators2;
6714
35
  int         offset = 0;
6715
35
  static int * const indicators1_fields[] = {
6716
35
    &hf_isup_odd_even_indicator,
6717
35
    &hf_isup_calling_party_nature_of_address_indicator,
6718
35
    NULL
6719
35
  };
6720
6721
35
  proto_tree_add_item(parameter_tree, hf_isup_number_qualifier_indicator, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
6722
35
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb,1 , 1, indicators1_fields, ENC_NA);
6723
35
  indicators1 = tvb_get_uint8(parameter_tvb, 1);
6724
35
  indicators2 = tvb_get_uint8(parameter_tvb, 2);
6725
35
  proto_tree_add_boolean(parameter_tree, hf_isup_ni_indicator, parameter_tvb, 2, 1, indicators2);
6726
35
  proto_tree_add_uint(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, 2, 1, indicators2);
6727
35
  if ((indicators2 & GFE_8BIT_MASK) == 0x50) {
6728
6
    proto_tree_add_uint_format_value(parameter_tree, hf_isup_number_different_meaning, parameter_tvb, 2, 1, indicators2 & GFE_8BIT_MASK,
6729
6
                                     "Numbering plan indicator = private numbering plan");
6730
6
  }
6731
35
  proto_tree_add_uint(parameter_tree, hf_isup_address_presentation_restricted_indicator, parameter_tvb, 2, 1, indicators2);
6732
35
  proto_tree_add_uint(parameter_tree, hf_isup_screening_indicator_enhanced, parameter_tvb, 2, 1, indicators2);
6733
35
  offset = 3;
6734
6735
35
  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
6736
35
                             hf_isup_generic_number, hf_isup_calling_party_odd_address_signal_digit,
6737
35
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
6738
35
                             NONE, 0);
6739
6740
  /*
6741
   * Indicators1 = Nature of address
6742
   * Indicators2 = Number plan indicator
6743
   */
6744
35
  indicators1 = indicators1 & 0x7f;
6745
35
  indicators2 = (indicators2 & 0x70)>>4;
6746
35
  if ((indicators1 == ISUP_CALLED_PARTY_NATURE_INTERNATNL_NR) && (indicators2 == ISDN_NUMBERING_PLAN))
6747
0
    dissect_e164_cc(parameter_tvb, pinfo, parameter_tree, 3, E164_ENC_BCD);
6748
35
}
6749
6750
/* ------------------------------------------------------------------
6751
  Dissector Parameter  Jurisdiction parameter
6752
 */
6753
static void
6754
dissect_isup_jurisdiction_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
6755
0
{
6756
0
  int         offset = 0;
6757
6758
0
  offset = 0;
6759
6760
0
  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
6761
0
                             hf_isup_jurisdiction, hf_isup_called_party_odd_address_signal_digit,
6762
0
                             hf_isup_called_party_even_address_signal_digit, (tvb_reported_length(parameter_tvb) > 0),
6763
0
                             NONE, 0);
6764
0
}
6765
6766
/* ------------------------------------------------------------------
6767
  Dissector Parameter Generic name
6768
 */
6769
static void
6770
dissect_isup_generic_name_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
6771
0
{
6772
0
  int     gen_name_length;
6773
0
  char   *gen_name = NULL;
6774
0
  static int * const indicators[] = {
6775
0
    &hf_isup_generic_name_presentation,
6776
0
    &hf_isup_generic_name_availability,
6777
0
    &hf_isup_generic_name_type,
6778
0
    NULL
6779
0
  };
6780
6781
0
  gen_name_length = tvb_reported_length(parameter_tvb) - 1;
6782
6783
0
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators, ENC_NA);
6784
6785
0
  gen_name = (char*)tvb_get_string_enc(pinfo->pool, parameter_tvb, 1, gen_name_length, ENC_ASCII);
6786
0
  proto_tree_add_string(parameter_tree, hf_isup_generic_name_ia5, parameter_tvb, 1, gen_name_length, gen_name);
6787
0
  proto_item_append_text(parameter_item, " : %s", gen_name);
6788
6789
0
  }
6790
6791
/* ------------------------------------------------------------------
6792
 Dissector Parameter Generic digits
6793
 */
6794
void
6795
dissect_isup_generic_digits_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6796
9
{ unsigned length = tvb_reported_length(parameter_tvb);
6797
9
  proto_tree_add_item(parameter_tree, hf_isup_generic_digits, parameter_tvb, 0, length, ENC_NA);
6798
9
}
6799
6800
/* ------------------------------------------------------------------
6801
  Dissector Parameter Charge number
6802
 */
6803
static void
6804
dissect_isup_charge_number_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
6805
0
{
6806
0
  uint8_t     indicators1;
6807
0
  int         offset = 0;
6808
0
  static int * const indicators1_fields[] = {
6809
0
    &hf_isup_odd_even_indicator,
6810
0
    &hf_isup_charge_number_nature_of_address_indicator,
6811
0
    NULL
6812
0
  };
6813
6814
0
  proto_tree_add_bitmask_list(parameter_tree, parameter_tvb, 0, 1, indicators1_fields, ENC_NA);
6815
0
  indicators1 = tvb_get_uint8(parameter_tvb, 0);
6816
0
  proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, 1, 1, ENC_NA);
6817
0
  offset = 2;
6818
6819
0
  dissect_isup_digits_common(parameter_tvb, offset, pinfo, parameter_tree, parameter_item,
6820
0
                             hf_isup_charge_number, hf_isup_calling_party_odd_address_signal_digit,
6821
0
                             hf_isup_calling_party_even_address_signal_digit, ((indicators1 & 0x80) == 0),
6822
0
                             NONE, 0);
6823
0
}
6824
6825
/* ------------------------------------------------------------------ */
6826
static void
6827
dissect_isup_unknown_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6828
576
{
6829
576
  unsigned length = tvb_reported_length(parameter_tvb);
6830
576
  proto_tree_add_item(parameter_tree, hf_isup_parameter_value, parameter_tvb, 0, length, ENC_NA);
6831
576
}
6832
/* ------------------------------------------------------------------ */
6833
6834
/* Japan ISUP */
6835
6836
/*
6837
  8 7 6 5 4 3 2 1
6838
  O/E Nature of address indicator 1
6839
  INN NAPI Spare 2
6840
  2nd address signal 1st address signal 3
6841
  ... ... :
6842
  Filler (if necessary) nth address signal 15
6843
*/
6844
static void
6845
dissect_japan_isup_called_dir_num(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
6846
0
{
6847
0
  unsigned offset = 0;
6848
0
  int parameter_length;
6849
6850
0
  parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);
6851
6852
0
  proto_tree_add_item(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
6853
0
  proto_tree_add_item(parameter_tree, hf_isup_called_party_nature_of_address_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
6854
0
  offset += 1;
6855
6856
0
  proto_tree_add_item(parameter_tree, hf_isup_inn_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
6857
0
  proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
6858
0
  offset += 1;
6859
6860
0
  proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, offset, parameter_length-offset, "Number not dissected yet");
6861
0
}
6862
6863
6864
/*
6865
  8     7     6     5     4     3     2    1
6866
  +-----+-----+-----+-----+-----+-----+-----+-----+
6867
  -            Information Type Tag               -  1
6868
  +-----------------------------------------------+
6869
  -           Information Type Length             -  2
6870
  +-----------------------------------------------+
6871
  -           Information Type Value              -  3
6872
  +-----------------------------------------------+
6873
  .                                              .
6874
  .                                              .
6875
  .                                              .
6876
  +-----------------------------------------------+
6877
  -            Information Type Tag               -  n+1
6878
  +-----------------------------------------------+
6879
  -           Information Type Length             -  n+2
6880
  +-----------------------------------------------+
6881
  -           Information Type Value              -  n+3
6882
  |-----------------------------------------------/
6883
6884
  Information Type Tag
6885
6886
  00000000  Reserved (Note)
6887
  00000001  Reserved
6888
  00000010  Reserved
6889
  00000011  Performing redirect indicator
6890
  00000100  Invoking redirect reason
6891
  00000101
6892
  to     Spare
6893
  11111111
6894
6895
  Note: In standard this value is marked as -Not used-,
6896
  here is treated as reserved.
6897
6898
  Performing redirect indicator
6899
6900
  8     7     6     5     4     3     2     1
6901
  +-----+-----+-----+-----+-----+-----+-----+-----+
6902
  - ext -      Performing redirect reason         -  1
6903
  +-----+-----------------------------------------+
6904
  -                             -Redirect possible-
6905
  -          Spare              -  indicator at   -  2
6906
  -                             -   performing    -
6907
  -                             -    exchange     -
6908
  +-----------------------------+-----------------+
6909
  :                       :                       :  :
6910
  :                       :                       :
6911
  +-----------------------------------------------+
6912
  - ext -      Performing redirect reason         -  2n|1
6913
  +-----+-----------------------|-----------------+    Reason n
6914
  -                             -Redirect possible-
6915
  -          Spare              -  indicator at   -  2n
6916
  -                             -   performing    -
6917
  -                             -    exchange     -
6918
  |-----------------------------+-----------------/
6919
6920
6921
  Redirect possible indicator at performing exchange
6922
  000      No indication
6923
  001      Redirect possible before ACM
6924
  010      Reserved
6925
  011      Reserved
6926
  100
6927
  to       Spare
6928
  111
6929
6930
  Invoking redirect reason
6931
6932
  8     7     6     5     4     3     2    1
6933
  +-----+-----+-----+-----+-----+-----+-----+-----+
6934
  - ext -        Invoking redirect reason         -  1
6935
  +-----+-----------------------------------------+
6936
  :     :                                         :
6937
  :     :                                         :
6938
  +-----------------------------------------------+
6939
  - ext -        Invoking redirect reason         -  n
6940
  |-----+-----------------------------------------/
6941
6942
  Extension indicator (ext)
6943
6944
  0        Information continues in next octet
6945
  1        Last octet
6946
6947
  Invoking redirect reason
6948
6949
  0000000  Unknown / not available
6950
  0000001  Service provider portability (national use)
6951
  0000010  Reserved for location portability
6952
  0000011  Reserved for service portability
6953
  0000100
6954
  to       Spare
6955
  0111111
6956
  1000000
6957
  to       Reserved for national use
6958
  1111101
6959
  1111110  Local number portability / Mobile number
6960
  portability
6961
  1111111  Reserved for national use
6962
6963
*/
6964
6965
static const value_string isup_rfi_info_type_values[] = {
6966
  { 0,   "Reserved" },
6967
  { 1,   "Reserved" },
6968
  { 2,   "Reserved" },
6969
  { 3,   "Performing redirect indicator" },
6970
  { 4,   "Invoking redirect reason" },
6971
  { 0,   NULL}
6972
};
6973
6974
/* Performing redirect reason */
6975
static const value_string perf_redir_reason_vals[] = {
6976
  { 0,   "Unknown/not available" },
6977
  { 1,   "Service provider portability (national use)" },
6978
  { 2,   "Reserved for location portability" },
6979
  { 3,   "Reserved for service portability" },
6980
/*
6981
  0000100
6982
  to       Spare
6983
  0111111
6984
  1000000
6985
  to       Reserved for national use
6986
  1111101
6987
*/
6988
  { 0x7e,   "Local number portability / Mobile number portability" },
6989
  { 0x7f,   "Reserved for national use" },
6990
  { 0,   NULL}
6991
};
6992
6993
6994
static const value_string redir_pos_ind_vals[] = {
6995
  { 0,   "No indication" },
6996
  { 1,   "Redirect possible before ACM" },
6997
  { 2,   "Reserved" },
6998
  { 3,   "Reserved" },
6999
  { 4,   "Reserved" },
7000
  { 5,   "Reserved" },
7001
  { 6,   "Reserved" },
7002
  { 7,   "Reserved" },
7003
  { 0,   NULL}
7004
};
7005
7006
7007
static void
7008
dissect_japan_isup_redirect_fwd_inf(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7009
0
{
7010
0
  int    offset = 0;
7011
0
  uint8_t tag, tag_len, ext_ind;
7012
0
  int    parameter_length;
7013
7014
0
  parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);
7015
7016
0
  while (offset < parameter_length) {
7017
    /* Information Type Tag */
7018
0
    tag = tvb_get_uint8(parameter_tvb, offset);
7019
0
    proto_tree_add_item(parameter_tree, hf_japan_isup_rfi_info_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7020
0
    offset += 1;
7021
    /* Information Type Length */
7022
0
    tag_len = tvb_get_uint8(parameter_tvb, offset);
7023
0
    proto_tree_add_item(parameter_tree, hf_japan_isup_rfi_info_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7024
0
    offset += 1;
7025
0
    switch (tag) {
7026
0
      case 3: /* Performing redirect indicator */
7027
        /* Performing redirect reason oct 1 */
7028
0
        ext_ind = 0;
7029
0
        while (ext_ind == 0) {
7030
0
          ext_ind = tvb_get_uint8(parameter_tvb, offset) >> 7;
7031
0
          proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7032
0
          proto_tree_add_item(parameter_tree, hf_japan_isup_perf_redir_reason, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7033
0
          offset += 1;
7034
          /* Redirect possible indicator at performing exchange */
7035
0
          proto_tree_add_item(parameter_tree, hf_japan_isup_redir_pos_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7036
0
          offset += 1;
7037
0
        }
7038
0
        break;
7039
0
      case 4:
7040
        /* Invoking redirect reason */
7041
0
        ext_ind = 0;
7042
0
        while (ext_ind == 0) {
7043
0
          ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
7044
0
          proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7045
0
          proto_tree_add_item(parameter_tree, hf_japan_isup_inv_redir_reason, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7046
0
          offset += 1;
7047
0
        }
7048
0
        break;
7049
0
      default:
7050
        /* Information Type Value */
7051
0
        proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, offset, tag_len, "Unknown(not dissected) tag");
7052
0
        offset = offset + tag_len;
7053
0
        break;
7054
0
    }
7055
0
  }
7056
0
}
7057
7058
7059
static const value_string japan_isup_bwd_info_type_vals[] = {
7060
  { 0,   "Reserved" },
7061
  { 1,   "Reserved" },
7062
  { 2,   "Reserved" },
7063
  { 3,   "invoking redirect reason" },
7064
  { 0,   NULL}
7065
};
7066
7067
static void
7068
dissect_japan_isup_redirect_backw_inf(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7069
0
{
7070
0
  int    offset = 0;
7071
0
  uint8_t tag, tag_len, ext_ind;
7072
0
  int    parameter_length;
7073
7074
0
  parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);
7075
7076
0
  while (offset < parameter_length) {
7077
    /* Information Type Tag */
7078
0
    proto_tree_add_item_ret_uint8(parameter_tree, hf_japan_isup_bwd_info_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN, &tag);
7079
0
    offset += 1;
7080
    /* Information Type Length */
7081
0
    proto_tree_add_item_ret_uint8(parameter_tree, hf_japan_isup_tag_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN, &tag_len);
7082
0
    offset += 1;
7083
0
    switch (tag) {
7084
0
      case 3: /* invoking redirect reason */
7085
        /* invoking redirect reason oct 1 */
7086
0
        ext_ind = 0;
7087
0
        while (ext_ind == 0) {
7088
0
          ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
7089
0
          proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7090
0
          proto_tree_add_item(parameter_tree, hf_japan_isup_inv_redir_reason, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7091
0
          offset += 1;
7092
0
        }
7093
0
        break;
7094
0
      default:
7095
        /* Information Type Value */
7096
0
        proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, offset, tag_len, "Unknown(not dissected) tag");
7097
0
        offset = offset + tag_len;
7098
0
        break;
7099
0
    }
7100
0
  }
7101
0
}
7102
7103
7104
static const value_string japan_isup_emerg_call_type_vals[] = {
7105
  { 0,   "No specific category" },
7106
  { 1,   "Spare" },
7107
  { 2,   "Spare" },
7108
  { 3,   "Spare" },
7109
  { 0,   NULL}
7110
};
7111
static void
7112
dissect_japan_isup_emergency_call_ind(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7113
0
{
7114
0
  unsigned offset = 0;
7115
7116
0
  proto_tree_add_item(parameter_tree, hf_japan_isup_emerg_call_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7117
0
}
7118
7119
static const value_string hold_at_emerg_call_disc_ind_vals[] = {
7120
  { 0,   "No indication" },
7121
  { 1,   "Emergency Call is holding" },
7122
  { 2,   "Call Back from the Emergency Center" },
7123
  { 3,   "Re-answer to an Emergency call" },
7124
  { 0,   NULL}
7125
};
7126
7127
static void
7128
dissect_japan_isup_emergency_call_inf_ind(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7129
0
{
7130
0
  unsigned offset = 0;
7131
7132
7133
0
  proto_tree_add_item(parameter_tree, hf_japan_isup_hold_at_emerg_call_disc_ind, parameter_tvb, offset, 2, ENC_BIG_ENDIAN);
7134
0
}
7135
7136
static void
7137
dissect_japan_isup_network_poi_cad(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7138
0
{
7139
0
  proto_item    *digits_item;
7140
0
  proto_tree    *digits_tree;
7141
0
  int            offset = 0;
7142
0
  uint8_t        octet;
7143
0
  uint8_t        odd_even;
7144
0
  uint8_t        carrier_info_length;
7145
0
  int            num_octets_with_digits = 0;
7146
0
  int            digit_index = 0;
7147
0
  wmem_strbuf_t *ca_number = wmem_strbuf_new_sized(pinfo->pool, MAXDIGITS+1);
7148
7149
  /* POI Hierarchy information
7150
7151
     8     7     6     5     4     3     2    1
7152
     +-----------------------|-----------------------+
7153
     |  Entry POI Hierarchy  |  Exit POI Hierarchy   |  1
7154
     |                       |                       |
7155
     \-----------------------------------------------|
7156
7157
  */
7158
7159
  /* POI Hierarchy information */
7160
0
  proto_tree_add_item(parameter_tree, hf_isup_carrier_info_poi_entry_HEI, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7161
0
  proto_tree_add_item(parameter_tree, hf_isup_carrier_info_poi_exit_HEI, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7162
0
  offset += 1;
7163
7164
  /* length of CA information (in octets) */
7165
0
  proto_tree_add_item_ret_uint8(parameter_tree, hf_japan_isup_carrier_info_length, parameter_tvb, offset, 1, ENC_BIG_ENDIAN, &carrier_info_length);
7166
0
  offset += 1;
7167
7168
  /* POI|CA information (Charge Area)
7169
7170
     8     7     6     5     4     3     2     1
7171
     +-----|-----------------------------------------+
7172
     |Odd/ |                Spare                    |  1
7173
     |even |                                         |
7174
     +-----------------------------------------------+
7175
     |   2nd CA code digit   |   1st CA code digit   |  2
7176
     |                       |                       |
7177
     +-----------------------+-----------------------+
7178
     .                      .                       .
7179
     .                      .                       .
7180
     .                      .                       .
7181
     +-----------------------+-----------------------+
7182
     |         Filler        |   5|th CA code digit  |  m
7183
     |                       |                       |
7184
     \-----------------------------------------------|
7185
  */
7186
7187
0
  digits_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1,
7188
0
                                ett_isup_address_digits, &digits_item, "Charge Area Number");
7189
7190
  /* Odd.Even Indicator*/
7191
0
  odd_even = tvb_get_uint8(parameter_tvb, offset);
7192
0
  proto_tree_add_boolean(digits_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, odd_even);
7193
7194
  /* Number of Octets containing digits*/
7195
0
  num_octets_with_digits = carrier_info_length - 1;
7196
7197
  /* Lets now load up the digits.*/
7198
  /* If the odd indicator is set... drop the Filler from the last octet.*/
7199
  /* This loop also loads up ca_number with the digits for display*/
7200
0
  digit_index = 0;
7201
0
  while (num_octets_with_digits > 0) {
7202
0
    offset += 1;
7203
0
    octet = tvb_get_uint8(parameter_tvb, offset);
7204
0
    if (++digit_index > MAXDIGITS) {
7205
0
      expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7206
0
      break;
7207
0
    }
7208
0
    proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_odd_no_digits, parameter_tvb, 0, 1, octet);
7209
0
    wmem_strbuf_append_c(ca_number, number_to_char(octet & ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK));
7210
0
    if (num_octets_with_digits == 1) {
7211
0
      if (odd_even == 0) {
7212
0
        if (++digit_index > MAXDIGITS) {
7213
0
          expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7214
0
          break;
7215
0
        }
7216
0
        proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
7217
0
        wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7218
0
      }
7219
0
    }
7220
0
    else {
7221
0
      if (++digit_index > MAXDIGITS) {
7222
0
        expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7223
0
        break;
7224
0
      }
7225
0
      proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
7226
0
      wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7227
0
    }
7228
7229
0
    num_octets_with_digits--;
7230
0
  }
7231
0
  proto_item_append_text(digits_item, ": %s", wmem_strbuf_get_str(ca_number));
7232
0
}
7233
7234
static const range_string jpn_isup_add_user_cat_type_vals[] = {
7235
  {  0,    0,    "Spare" },
7236
  {  1,    0x80, "Reserved for network specific use" },
7237
  {  0x81, 0xfa, "Spare" },
7238
  {  0xfb, 0xfb, "Type 3 of additional mobile service information" },
7239
  {  0xfc, 0xfc, "Type 2 of additional mobile service information" },
7240
  {  0xfd, 0xfd, "Type 1 of additional mobile service information" },
7241
  {  0xfe, 0xfe, "Type 1 of additional fixed service information" },
7242
  {  0xff, 0xff, "Spare" },
7243
  {  0,    0,    NULL } };
7244
7245
static const value_string jpn_isup_type_1_add_fixed_serv_inf_vals[] = {
7246
  { 0,   "Spare" },
7247
  { 1,   "Train payphone" },
7248
  { 2,   "Pink (non-NTT payphone)" },
7249
  { 0,   NULL}
7250
};
7251
7252
static const value_string jpn_isup_type_1_add_mobile_serv_inf_vals[] = {
7253
  { 0,   "Spare" },
7254
  { 1,   "Cellular telephone service" },
7255
  { 2,   "Maritime telephone service" },
7256
  { 3,   "Airplane telephone service" },
7257
  { 4,   "Paging service" },
7258
  { 5,   "PHS service" },
7259
  { 6,   "Spare" },
7260
  { 0,   NULL}
7261
};
7262
static const value_string jpn_isup_type_2_add_mobile_serv_inf_vals[] = {
7263
  { 0,   "Spare" },
7264
  { 1,   "HiCap method (analog)" },
7265
  { 2,   "N/J-TACS" },
7266
  { 3,   "PDC 800 MHz" },
7267
  { 4,   "PDC 1500 MHz" },
7268
  { 5,   "N-STAR satellite" },
7269
  { 6,   "cdmaOne 800 MHz" },
7270
  { 7,   "Iridium satellite" },
7271
  { 8,   "IMT-2000" },
7272
  { 9,   "PHS (fixed network dependent)" },
7273
  { 10,   "Spare" },
7274
  { 0,   NULL}
7275
};
7276
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);
7277
7278
7279
void
7280
dissect_japan_isup_additonal_user_cat(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7281
0
{
7282
0
  int    offset = 0;
7283
0
  uint8_t type;
7284
0
  int    parameter_length;
7285
7286
0
  parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);
7287
7288
0
  while (offset < parameter_length) {
7289
    /* Type of Additional User/Service Information */
7290
0
    proto_tree_add_item_ret_uint8(parameter_tree, hf_japan_isup_add_user_cat_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN, &type);
7291
0
    offset += 1;
7292
    /* Additional User/Service Information  */
7293
0
    switch (type) {
7294
0
      case 0xfe:
7295
        /* Type 1 of additional fixed service information */
7296
0
        proto_tree_add_item(parameter_tree, hf_japan_isup_type_1_add_fixed_serv_inf, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7297
0
        break;
7298
0
      case 0xfd:
7299
        /* Type 1 of additional mobile service information */
7300
0
        proto_tree_add_item(parameter_tree, hf_japan_isup_type_1_add_mobile_serv_inf, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7301
0
        break;
7302
0
      case 0xfc:
7303
        /* Type 2 of additional mobile service information */
7304
0
        proto_tree_add_item(parameter_tree, hf_japan_isup_type_2_add_mobile_serv_inf, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7305
0
        break;
7306
0
      case 0xfb:
7307
        /* Type 3 of additional mobile service information */
7308
0
        proto_tree_add_item(parameter_tree, hf_japan_isup_type_3_add_mobile_serv_inf, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7309
0
        break;
7310
0
      default:
7311
0
        proto_tree_add_expert_format(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, offset, 1,
7312
0
                "Unknown(not dissected) Additional User/Service Information");
7313
0
        break;
7314
0
    }
7315
0
    offset += 1;
7316
0
  }
7317
0
}
7318
7319
7320
static const value_string jpn_isup_reason_for_clip_fail_vals[] = {
7321
  { 0,   "Spare" },
7322
  { 1,   "User's request" },
7323
  { 2,   "Interaction with other service" },
7324
  { 3,   "Public telephone origination" },
7325
  { 4,   "Spare" },
7326
  { 0,   NULL}
7327
};
7328
static void
7329
dissect_japan_isup_reason_for_clip_fail(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7330
0
{
7331
0
  unsigned offset = 0;
7332
7333
7334
0
  proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7335
0
  proto_tree_add_item(parameter_tree, hf_japan_isup_reason_for_clip_fail, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7336
0
}
7337
7338
static void
7339
dissect_japan_isup_contractor_number(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
7340
0
{
7341
0
  int         offset = 0;
7342
0
  int         parameter_length;
7343
0
  char        *digit_str;
7344
7345
0
  parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);
7346
7347
0
  proto_tree_add_item(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7348
0
  proto_tree_add_item(parameter_tree, hf_isup_called_party_nature_of_address_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7349
0
  offset += 1;
7350
7351
0
  proto_tree_add_item(parameter_tree, hf_isup_numbering_plan_indicator, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7352
0
  offset += 1;
7353
7354
0
  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);
7355
7356
0
  proto_item_append_text(parameter_item, " %s", digit_str);
7357
7358
0
}
7359
/* ------------------------------------------------------------------
7360
  Dissector Parameter Optional .Carrier Information
7361
7362
7363
   8     7     6     5     4     3     2    1
7364
+-----------------------------------------------+
7365
|                 spare             |    IEC    |  1
7366
|                                   | indicator |
7367
+-----------------------------------------------+
7368
|         Category of carrier 1                 |  2
7369
|                                               |
7370
+-----------------------------------------------+
7371
|         Length of carrier 1 information       |  3
7372
|                                               |
7373
+-----------------------------------------------+
7374
|         Carrier 1 information / octet 1       |  4
7375
|                                               |
7376
+-----------------------------------------------+
7377
 .                    .                         .
7378
 .                    .                         .
7379
 .                    .                         .
7380
+-----------------------------------------------+
7381
|         Carrier 1 information / octet n       |  3+n
7382
|                                               |
7383
+-----------------------------------------------+
7384
 .                                              .
7385
 */
7386
static void
7387
dissect_japan_isup_carrier_information(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
7388
0
{
7389
0
  proto_item *catagory_of_carrier;
7390
0
  proto_tree *carrier_info_tree;
7391
7392
0
  proto_item *digits_item;
7393
0
  proto_tree *digits_tree;
7394
7395
0
  proto_item *type_of_carrier;
7396
0
  proto_tree *type_of_carrier_tree;
7397
7398
0
  uint8_t octet;
7399
0
  uint8_t odd_even;
7400
0
  uint8_t type_of_carrier_info;
7401
0
  uint8_t carrier_info_length;
7402
0
  uint8_t carrierX_end_index;
7403
7404
0
  unsigned offset = 0;
7405
0
  int length = 0;
7406
7407
0
  int num_octets_with_digits = 0;
7408
7409
0
  int digit_index;
7410
0
  wmem_strbuf_t *cid_number;
7411
0
  wmem_strbuf_t *ca_number;
7412
7413
  /*Octet 1 : IEC Indicator*/
7414
0
  octet = tvb_get_uint8(parameter_tvb, 0);
7415
0
  proto_tree_add_uint(parameter_tree, hf_isup_carrier_info_iec, parameter_tvb, 0, 1, octet);
7416
7417
7418
0
  length = tvb_reported_length_remaining(parameter_tvb, 2);
7419
0
  if (length == 0) {
7420
0
    expert_add_info(pinfo, parameter_item, &ei_isup_empty_number);
7421
0
    proto_item_append_text(parameter_item, ": (empty)");
7422
0
    return;
7423
0
  }
7424
7425
0
  offset = 1;
7426
7427
  /* Lets loop through the Carrier Information*/
7428
7429
0
  while (length > 0) {
7430
7431
0
    carrier_info_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1,
7432
0
                        ett_isup_carrier_info, &catagory_of_carrier, "Category of Carrier:");
7433
7434
    /*Octet 2 : Category of Carrier*/
7435
0
    octet = tvb_get_uint8(parameter_tvb, offset);
7436
    /*proto_tree_add_uint(carrier_info_tree, hf_isup_carrier_info_cat_of_carrier, parameter_tvb, 0, 1, octet);*/
7437
0
    proto_item_append_text(catagory_of_carrier, ": %s (%u)", val_to_str_ext_const(octet, &isup_carrier_info_category_vals_ext, "spare"), octet );
7438
7439
7440
    /*Octet 3 : Length of Category Information No.x*/
7441
0
    offset += 1;
7442
0
    carrierX_end_index = tvb_get_uint8(parameter_tvb, offset)+offset;
7443
7444
0
    while (offset < carrierX_end_index) {
7445
7446
0
      type_of_carrier_tree = proto_tree_add_subtree(carrier_info_tree, parameter_tvb, offset, -1,
7447
0
                                    ett_isup_carrier_info, &type_of_carrier, "Type of Carrier:");
7448
7449
      /* Type of Carrier Information*/
7450
0
      offset += 1;
7451
0
      type_of_carrier_info = tvb_get_uint8(parameter_tvb, offset);
7452
      /*proto_tree_add_uint(type_of_carrier_tree, hf_isup_carrier_info_type_of_carrier_info, parameter_tvb, 0, 1, type_of_carrier_info);*/
7453
0
      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 );
7454
7455
7456
      /* Carrier Information Length */
7457
0
      offset += 1;
7458
0
      carrier_info_length = tvb_get_uint8(parameter_tvb, offset);
7459
7460
      /* POI Hierarchy information
7461
7462
         8     7     6     5     4     3     2    1
7463
         +-----------------------|-----------------------+
7464
         |  Entry POI Hierarchy  |  Exit POI Hierarchy   |  1
7465
         |                       |                       |
7466
         \-----------------------------------------------|
7467
7468
      */
7469
7470
0
      if (type_of_carrier_info == CARRIER_INFO_TYPE_OF_CARRIER_POIHIE) {
7471
        /* POI Hierarchy information */
7472
0
        offset += 1;
7473
0
        octet = tvb_get_uint8(parameter_tvb, offset);
7474
0
        proto_tree_add_uint(type_of_carrier_tree, hf_isup_carrier_info_poi_entry_HEI, parameter_tvb, 0, 1, octet);
7475
0
        proto_tree_add_uint(type_of_carrier_tree, hf_isup_carrier_info_poi_exit_HEI, parameter_tvb, 0, 1, octet);
7476
0
      }
7477
7478
      /* POI|CA information (Charge Area)
7479
7480
         8     7     6     5     4     3     2     1
7481
         +-----|-----------------------------------------+
7482
         |Odd/ |                Spare                    |  1
7483
         |even |                                         |
7484
         +-----------------------------------------------+
7485
         |   2nd CA code digit   |   1st CA code digit   |  2
7486
         |                       |                       |
7487
         +-----------------------+-----------------------+
7488
         .                      .                       .
7489
         .                      .                       .
7490
         .                      .                       .
7491
         +-----------------------+-----------------------+
7492
         |         Filler        |   5|th CA code digit  |  m
7493
         |                       |                       |
7494
         \-----------------------------------------------|
7495
      */
7496
0
      if (type_of_carrier_info == CARRIER_INFO_TYPE_OF_CARRIER_POICA) {
7497
7498
0
        digits_tree = proto_tree_add_subtree(type_of_carrier_tree, parameter_tvb, offset, -1,
7499
0
                                        ett_isup_address_digits, &digits_item, "Charge Area");
7500
7501
        /* Odd.Even Indicator*/
7502
0
        offset += 1;
7503
0
        odd_even = tvb_get_uint8(parameter_tvb, offset);
7504
0
        proto_tree_add_boolean(digits_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, odd_even);
7505
7506
        /* Number of Octets containing digits*/
7507
0
        num_octets_with_digits = carrier_info_length - 1;
7508
7509
        /* Lets now load up the digits.*/
7510
        /* If the odd indicator is set... drop the Filler from the last octet.*/
7511
        /* This loop also loads up ca_number with the digits for display*/
7512
0
        ca_number = wmem_strbuf_new_sized(pinfo->pool, MAXDIGITS+1);
7513
0
        digit_index = 0;
7514
0
        while (num_octets_with_digits > 0) {
7515
0
          offset += 1;
7516
0
          if (++digit_index > MAXDIGITS) {
7517
0
            expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7518
0
            break;
7519
0
          }
7520
0
          octet = tvb_get_uint8(parameter_tvb, offset);
7521
0
          proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_odd_no_digits, parameter_tvb, 0, 1, octet);
7522
0
          wmem_strbuf_append_c(ca_number, number_to_char(octet & ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK));
7523
0
          if (num_octets_with_digits == 1) {
7524
0
            if (odd_even == 0) {
7525
0
              if (++digit_index > MAXDIGITS) {
7526
0
                expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7527
0
                break;
7528
0
              }
7529
0
              proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
7530
0
              wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7531
0
            }
7532
0
          }
7533
0
          else {
7534
0
            if (++digit_index > MAXDIGITS) {
7535
0
              expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7536
0
              break;
7537
0
            }
7538
0
            proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
7539
0
            wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7540
0
          }
7541
7542
0
          num_octets_with_digits--;
7543
0
        }
7544
7545
0
        proto_item_append_text(digits_item, ": %s", wmem_strbuf_get_str(ca_number));
7546
7547
0
      }
7548
7549
      /* Carrier Identification Code
7550
         8     7     6     5     4     3     2     1
7551
         +-----|-----------------------------------------+
7552
         |Odd/ |                Spare                    |  1
7553
         |even |                                         |
7554
         +-----------------------------------------------+
7555
         |   2nd ID code digit   |   1st ID code digit   |  2
7556
         |                       |                       |
7557
         +-----------------------+-----------------------+
7558
         .                      .                       .
7559
         .                      .                       .
7560
         .                      .                       .
7561
         +-----------------------+-----------------------+
7562
         | Filler (if necessary) |   n|th ID code digit  |  m
7563
         |                       |                       |
7564
         \-----------------------------------------------|
7565
      */
7566
7567
0
      if (type_of_carrier_info == CARRIER_INFO_TYPE_OF_CARRIER_CARID) {
7568
0
        digits_tree = proto_tree_add_subtree(type_of_carrier_tree, parameter_tvb, offset, -1,
7569
0
                                        ett_isup_address_digits, &digits_item, "Carrier ID Code");
7570
7571
0
        offset += 1;
7572
        /* Odd.Even Indicator*/
7573
0
        odd_even = tvb_get_uint8(parameter_tvb, offset);
7574
0
        proto_tree_add_boolean(digits_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, odd_even);
7575
7576
        /* Number of Octets containing digits*/
7577
0
        num_octets_with_digits = carrier_info_length - 1;
7578
7579
        /* Lets now load up the digits.*/
7580
        /* If the odd indicator is set... drop the Filler from the last octet.*/
7581
        /* This loop also loads up cid_number with the digits for display*/
7582
0
        cid_number = wmem_strbuf_new_sized(pinfo->pool, MAXDIGITS+1);
7583
0
        digit_index = 0;
7584
0
        while (num_octets_with_digits > 0) {
7585
0
          offset += 1;
7586
0
          if (++digit_index > MAXDIGITS) {
7587
0
            expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7588
0
            break;
7589
0
          }
7590
0
          octet = tvb_get_uint8(parameter_tvb, offset);
7591
0
          proto_tree_add_uint(digits_tree, hf_isup_carrier_info_odd_no_digits, parameter_tvb, 0, 1, octet);
7592
0
          wmem_strbuf_append_c(cid_number, number_to_char(octet & ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK));
7593
0
          if (num_octets_with_digits == 1) {
7594
0
            if (odd_even == 0) {
7595
0
              if (++digit_index > MAXDIGITS) {
7596
0
                expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7597
0
                break;
7598
0
              }
7599
0
              proto_tree_add_uint(digits_tree, hf_isup_carrier_info_even_no_digits, parameter_tvb, 0, 1, octet);
7600
0
              wmem_strbuf_append_c(cid_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7601
0
            }
7602
0
          }
7603
0
          else {
7604
0
            if (++digit_index > MAXDIGITS) {
7605
0
              expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7606
0
              break;
7607
0
            }
7608
0
            proto_tree_add_uint(digits_tree, hf_isup_carrier_info_even_no_digits, parameter_tvb, 0, 1, octet);
7609
0
            wmem_strbuf_append_c(cid_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7610
0
          }
7611
0
          num_octets_with_digits--;
7612
0
        }
7613
0
        proto_item_append_text(digits_item, ": %s", wmem_strbuf_get_str(cid_number));
7614
0
      }
7615
0
    }
7616
7617
0
    offset += 1;
7618
0
    length = tvb_reported_length_remaining(parameter_tvb, offset);
7619
0
  }
7620
0
}
7621
7622
7623
static const range_string japan_isup_charge_delay_type_value[] = {
7624
  {  0,    0,    "Spare" },
7625
  {  1,    0x80, "Reserved for network specific use" },
7626
  {  0x81, 0xfa, "Spare" },
7627
  {  0xfb, 0xfc, "Reserved" },
7628
  {  0xfd, 0xfd, "Charge rate transfer" },
7629
  {  0xfe, 0xfe, "Terminating charge area information" },
7630
  {  0xff, 0xff, "Spare" },
7631
  {  0,    0,    NULL } };
7632
7633
static void
7634
dissect_japan_isup_charge_inf_delay(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7635
0
{
7636
7637
0
  unsigned offset = 0;
7638
0
  unsigned parameter_length;
7639
7640
0
  parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);
7641
7642
0
  while (offset < parameter_length) {
7643
0
    proto_tree_add_item(parameter_tree, hf_japan_isup_charge_delay_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7644
0
    offset += 1;
7645
0
  }
7646
0
}
7647
7648
/* ----------------------------------------------------
7649
  Dissector Parameter Optional .Additional User Information
7650
7651
   8     7     6     5     4     3     2    1
7652
+-----------------------------------------------+
7653
|     Type of additional user/service           |  1
7654
|     information (1)                           |
7655
+-----------------------------------------------+
7656
|     Additional user/service information (1)   |  2
7657
|                                               |
7658
+-----------------------------------------------+
7659
 .                                              .
7660
 .                                              .
7661
 .                                              .
7662
+-----------------------------------------------+
7663
|      Type of additional user/service          |  2n|1
7664
|      information (n)                          |
7665
+-----------------------------------------------+
7666
|      Additional user/service information (n)  |  2n
7667
|                                               |
7668
\------------------------------------------------
7669
*/
7670
7671
7672
7673
/* ----------------------------------------------------
7674
  Dissector Parameter Optional .Charge Area Information
7675
7676
  8     7     6     5     4     3     2     1
7677
+-----+-----------------------------------------+
7678
|Odd/ |     Nature of information indicator     |  1
7679
|even |                                         |
7680
+-----------------------------------------------+
7681
| 2nd NC digit          | 1st NC digit          |  2 ||
7682
|                       |                       |     | see
7683
+-----------------------+-----------------------+     | Note
7684
|  4th NC digit         | 3rd NC digit          |  3 ||
7685
|                       |                       |
7686
+-----------------------+-----------------------+
7687
| 2nd MA/CA code digit  | 1st MA/CA code digit  |  4
7688
|                       |                       |
7689
+-----------------------+-----------------------+
7690
 .                      .                       .
7691
 .                      .                       .
7692
 .                      .                       .
7693
+-----------------------+-----------------------+
7694
| Filler (if necessary) | nth MA/CA code digit  |  m
7695
|                       |                       |
7696
\-----------------------------------------------|
7697
*/
7698
static void
7699
dissect_japan_isup_charge_area_info(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7700
0
{
7701
0
  proto_item *digits_item;
7702
0
  proto_tree *digits_tree;
7703
7704
0
  uint8_t octet;
7705
7706
0
  int nat_of_info_indic;
7707
0
  int length;
7708
0
  unsigned offset;
7709
0
  int odd_even;
7710
0
  int digit_index = 0;
7711
7712
0
  wmem_strbuf_t *ca_number = wmem_strbuf_new_sized(pinfo->pool, MAXDIGITS+1);
7713
7714
  /*Octet 1 : Indicator*/
7715
0
  octet = tvb_get_uint8(parameter_tvb, 0);
7716
0
  nat_of_info_indic = octet & 0x7F;
7717
0
  odd_even = octet & 0x80;
7718
0
  proto_tree_add_boolean(parameter_tree, hf_isup_odd_even_indicator, parameter_tvb, 0, 1, octet);
7719
0
  proto_tree_add_uint(parameter_tree, hf_japan_isup_charge_area_nat_of_info_value, parameter_tvb, 0, 1, octet);
7720
7721
0
  offset = 1;
7722
0
  length = tvb_reported_length_remaining(parameter_tvb, offset);
7723
7724
  /*Only CA code digits.*/
7725
0
  if (nat_of_info_indic == CHARGE_AREA_NAT_INFO_CA) {
7726
0
    digits_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1,
7727
0
                                ett_isup_address_digits, &digits_item, "Charge Area");
7728
7729
0
    while (length > 0) {
7730
0
      if (++digit_index > MAXDIGITS) {
7731
0
        expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7732
0
        break;
7733
0
      }
7734
0
      octet = tvb_get_uint8(parameter_tvb, offset);
7735
0
      proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_odd_no_digits, parameter_tvb, 0, 1, octet);
7736
0
      wmem_strbuf_append_c(ca_number, number_to_char(octet & ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK));
7737
0
      if (length == 1) {
7738
0
        if (odd_even == 0) {
7739
0
          if (++digit_index > MAXDIGITS) {
7740
0
            expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7741
0
            break;
7742
0
          }
7743
0
          proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
7744
0
          wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7745
0
        }
7746
0
      }
7747
0
      else {
7748
0
        if (++digit_index > MAXDIGITS) {
7749
0
          expert_add_info(pinfo, digits_item, &ei_isup_too_many_digits);
7750
0
          break;
7751
0
        }
7752
0
        proto_tree_add_uint(digits_tree, hf_isup_carrier_info_ca_even_no_digits, parameter_tvb, 0, 1, octet);
7753
0
        wmem_strbuf_append_c(ca_number, number_to_char((octet & ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK) / 0x10));
7754
0
      }
7755
0
      offset += 1;
7756
0
      length -= 1;
7757
0
    }
7758
0
    proto_item_append_text(digits_item, ": %s", wmem_strbuf_get_str(ca_number));
7759
0
  }
7760
  /*Only MA code digits.*/
7761
0
  if (nat_of_info_indic == CHARGE_AREA_NAT_INFO_MA) {
7762
0
    digits_tree = proto_tree_add_subtree(parameter_tree, parameter_tvb, offset, -1,
7763
0
                                ett_isup_address_digits, &digits_item, "Message Area:");
7764
7765
    /* First two octets contains*/
7766
    /* four NC digits*/
7767
0
    octet = tvb_get_uint8(parameter_tvb, offset);
7768
0
    proto_tree_add_uint(digits_tree, hf_japan_isup_charging_info_nc_odd_digits, parameter_tvb, 0, 1, octet);
7769
0
    proto_tree_add_uint(digits_tree, hf_japan_isup_charging_info_nc_even_digits, parameter_tvb, 0, 1, octet);
7770
0
    offset++;
7771
0
    octet = tvb_get_uint8(parameter_tvb, offset);
7772
0
    proto_tree_add_uint(digits_tree, hf_japan_isup_charging_info_nc_odd_digits, parameter_tvb, 0, 1, octet);
7773
0
    proto_tree_add_uint(digits_tree, hf_japan_isup_charging_info_nc_even_digits, parameter_tvb, 0, 1, octet);
7774
0
    offset++;
7775
7776
    /* Now loop through MA/CA digits.*/
7777
0
    length = tvb_reported_length_remaining(parameter_tvb, offset);
7778
7779
0
    while (length > 0) {
7780
0
      octet = tvb_get_uint8(parameter_tvb, offset);
7781
0
      proto_tree_add_uint(digits_tree, hf_isup_charging_info_maca_odd_digits, parameter_tvb, 0, 1, octet);
7782
0
      if (length == 1) {
7783
0
        if (odd_even == 0) {
7784
0
          proto_tree_add_uint(digits_tree, hf_isup_charging_info_maca_even_digits, parameter_tvb, 0, 1, octet);
7785
0
        }
7786
0
      }
7787
0
      else {
7788
0
        proto_tree_add_uint(digits_tree, hf_isup_charging_info_maca_even_digits, parameter_tvb, 0, 1, octet);
7789
0
      }
7790
0
      offset += 1;
7791
0
      length -= 1;
7792
0
    }
7793
7794
0
  }
7795
0
}
7796
7797
static const value_string japan_isup_chg_info_type_value[] = {
7798
  { 0,      "Spare" },
7799
  { 1,      "Reserved" },
7800
  { 2,      "Reserved" },
7801
  { 3,      "Advanced Charge Rate Transfer(TDS Service)" },
7802
  { 0xfe,   "Charge rate transfer (flexible charging)" },
7803
  { 0xff,   "Spare" },
7804
  { 0,   NULL}
7805
};
7806
7807
static uint16_t
7808
dissect_japan_chg_inf_type(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7809
0
{
7810
0
  uint16_t chg_inf_type;
7811
7812
0
  chg_inf_type = tvb_get_uint8(parameter_tvb, 0);
7813
0
  proto_tree_add_item(parameter_tree, hf_japan_isup_charge_info_type, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
7814
7815
0
  return chg_inf_type;
7816
0
}
7817
7818
static const value_string japan_isup_sig_elem_type_values[] = {
7819
  { 2,   "Activate" },
7820
  { 0,   NULL}
7821
};
7822
7823
static const value_string japan_isup_op_cls_values[] = {
7824
  { 0,   "Class 1" },
7825
  { 1,   "Class 2" },
7826
  { 2,   "Class 3" },
7827
  { 3,   "Class 4" },
7828
  { 0,   NULL}
7829
};
7830
7831
static const value_string japan_isup_op_type_values[] = {
7832
  { 6,   "Immediate charging" },
7833
  { 0,   NULL}
7834
};
7835
7836
static const value_string japan_isup_charging_party_type_values[] = {
7837
  { 0,   "Originator charge" },
7838
  { 0,   NULL}
7839
};
7840
7841
static const value_string japan_isup_collecting_method_values[] = {
7842
  { 0,   "Subscriber will be claimed" },
7843
  { 0,   NULL}
7844
};
7845
7846
static const value_string japan_isup_tariff_rate_pres_values[] = {
7847
  { 2,   "No charge rate information" },
7848
  { 0,   NULL}
7849
};
7850
7851
static void
7852
dissect_japan_chg_inf_type_acr(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7853
0
{
7854
0
  int    offset = 0;
7855
0
  uint8_t ext_ind;
7856
7857
  /* length : 2-5 octets */
7858
0
  ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
7859
0
  proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7860
0
  proto_tree_add_item(parameter_tree, hf_japan_isup_sig_elem_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7861
0
  offset += 1;
7862
0
  if (!ext_ind) {
7863
    /* Activation ID */
7864
0
    ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
7865
0
    proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7866
0
    proto_tree_add_item(parameter_tree, hf_japan_isup_activation_id, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7867
0
    offset += 1;
7868
0
    if (!ext_ind) {
7869
      /* Operation type and class */
7870
0
      ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
7871
0
      proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7872
0
      proto_tree_add_item(parameter_tree, hf_japan_isup_op_cls, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7873
0
      proto_tree_add_item(parameter_tree, hf_japan_isup_op_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7874
0
      offset += 1;
7875
0
      if (!ext_ind) {
7876
        /* Tariff collecting method and charging party type */
7877
0
        proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7878
0
        proto_tree_add_item(parameter_tree, hf_japan_isup_charging_party_type, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7879
0
        proto_tree_add_item(parameter_tree, hf_japan_isup_collecting_method, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7880
0
        offset += 1;
7881
0
      }
7882
0
    }
7883
0
  }
7884
  /* Tariff rate presentation */
7885
0
  proto_tree_add_item(parameter_tree, hf_japan_isup_tariff_rate_pres, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7886
7887
0
}
7888
7889
7890
static const value_string japan_isup_utp_values[] = {
7891
  { 0,   "Spare" },
7892
  { 0xfc,   "100 yen" },
7893
  { 0xfd,   "10 yen" },
7894
  { 0xfe,   "No indication" },
7895
  { 0xff,   "Spare" },
7896
  { 0,   NULL}
7897
};
7898
7899
static const value_string japan_isup_crci1_values[] = {
7900
  { 0,   "Spare" },
7901
  { 0x7c,   "Public (Payphone)" },
7902
  { 0x7d,   "Ordinary" },
7903
  { 0x7e,   "No flexible charge rate information" },
7904
  { 0x7f,   "Spare" },
7905
  { 0,   NULL}
7906
};
7907
7908
static void
7909
dissect_japan_chg_inf_type_crt(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
7910
0
{
7911
0
  int    offset = 0;
7912
0
  uint8_t ext_ind;
7913
0
  uint8_t len;
7914
0
  int    parameter_length;
7915
7916
0
  parameter_length = tvb_reported_length_remaining(parameter_tvb, offset);
7917
7918
7919
  /* Unit per Time Period (UTP) */
7920
0
  proto_tree_add_item(parameter_tree, hf_japan_isup_utp, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7921
0
  offset += 1;
7922
7923
  /* Charge rate information category 1 (CRIC 1) */
7924
0
  ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
7925
0
  proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7926
0
  proto_tree_add_item(parameter_tree, hf_japan_isup_crci1, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7927
0
  offset += 1;
7928
0
  if (!ext_ind) {
7929
0
    proto_tree_add_item_ret_uint8(parameter_tree, hf_japan_isup_crci1_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN, &len);
7930
0
    offset += 1;
7931
    /* Initial units (IU) IA5 coded in two octets */
7932
0
    proto_tree_add_item(parameter_tree, hf_japan_isup_iu, parameter_tvb, offset, 2, ENC_ASCII);
7933
0
    offset += 2;
7934
    /* Daytime Charge rate (DCR) (Octets A, B, C) IA5 coded in three octets */
7935
0
    proto_tree_add_item(parameter_tree, hf_japan_isup_dcr, parameter_tvb, offset, 3, ENC_ASCII);
7936
0
    offset+=3;
7937
0
    if (len > 5) {
7938
      /* Evening Charge rate (ECR) (Octets B, E, F) IA5 coded in three octets */
7939
0
      proto_tree_add_item(parameter_tree, hf_japan_isup_ecr, parameter_tvb, offset, 3, ENC_ASCII);
7940
0
      offset += 3;
7941
0
    }
7942
0
    if (len > 8) {
7943
      /* Nighttime Charge rate (NCR) (Octet G,H,I) IA5 coded in three octets */
7944
0
      proto_tree_add_item(parameter_tree, hf_japan_isup_ncr, parameter_tvb, offset, 3, ENC_ASCII);
7945
0
      offset += 3;
7946
0
    }
7947
0
    if (len > 11) {
7948
      /* Spare charge rate (SCR) (Octets J,K,L) IA5 coded in three octets */
7949
0
      proto_tree_add_item(parameter_tree, hf_japan_isup_scr, parameter_tvb, offset, 3, ENC_ASCII);
7950
0
      offset += 3;
7951
0
    }
7952
0
  }
7953
0
  if (parameter_length > offset) {
7954
    /* Charge rate information category 2 (CRIC 2) */
7955
0
    ext_ind = tvb_get_uint8(parameter_tvb, offset)>>7;
7956
0
    proto_tree_add_item(parameter_tree, hf_isup_extension_ind, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7957
0
    proto_tree_add_item(parameter_tree, hf_japan_isup_crci2, parameter_tvb, offset, 1, ENC_BIG_ENDIAN);
7958
0
    offset += 1;
7959
0
    if (!ext_ind) {
7960
0
      proto_tree_add_item_ret_uint8(parameter_tree, hf_japan_isup_crci1_len, parameter_tvb, offset, 1, ENC_BIG_ENDIAN, &len);
7961
0
      offset += 1;
7962
      /* Initial units (IU) IA5 coded in two octets */
7963
0
      proto_tree_add_item(parameter_tree, hf_japan_isup_iu, parameter_tvb, offset, 2, ENC_ASCII);
7964
0
      offset += 2;
7965
      /* Daytime Charge rate (DCR) (Octets A, B, C) IA5 coded in three octets */
7966
0
      proto_tree_add_item(parameter_tree, hf_japan_isup_dcr, parameter_tvb, offset, 3, ENC_ASCII);
7967
0
      offset += 3;
7968
0
      if (len > 5) {
7969
        /* Evening Charge rate (ECR) (Octets B, E, F) IA5 coded in three octets */
7970
0
        proto_tree_add_item(parameter_tree, hf_japan_isup_ecr, parameter_tvb, offset, 3, ENC_ASCII);
7971
0
        offset += 3;
7972
0
      }
7973
0
      if (len > 8) {
7974
        /* Nighttime Charge rate (NCR) (Octet G,H,I) IA5 coded in three octets */
7975
0
        proto_tree_add_item(parameter_tree, hf_japan_isup_ncr, parameter_tvb, offset, 3, ENC_ASCII);
7976
0
        offset += 3;
7977
0
      }
7978
0
      if (len > 11) {
7979
        /* Spare charge rate (SCR) (Octets J,K,L) IA5 coded in three octets */
7980
0
        proto_tree_add_item(parameter_tree, hf_japan_isup_scr, parameter_tvb, offset, 3, ENC_ASCII);
7981
        /*offset += 3;*/
7982
0
      }
7983
0
    }
7984
0
  }
7985
0
}
7986
7987
7988
static void
7989
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)
7990
0
{
7991
7992
0
  switch (chg_inf_type) {
7993
0
    case 3:
7994
      /* Advanced Charge Rate Transfer (TDS service) */
7995
0
      dissect_japan_chg_inf_type_acr(parameter_tvb, parameter_tree, parameter_item);
7996
0
      break;
7997
0
    case 254:
7998
      /* Charge rate transfer (flexible charging) */
7999
0
      dissect_japan_chg_inf_type_crt(parameter_tvb, parameter_tree, parameter_item);
8000
0
      break;
8001
0
    default:
8002
0
      proto_tree_add_expert_format_remaining(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, 0, "Charge information data, not dissected yet");
8003
0
      break;
8004
0
  }
8005
0
}
8006
8007
/* END Japan ISUP */
8008
8009
/* ------------------------------------------------------------------
8010
  Dissector all optional parameters
8011
*/
8012
static void
8013
dissect_isup_optional_parameter(tvbuff_t *optional_parameters_tvb, packet_info *pinfo, proto_tree *isup_tree, uint8_t itu_isup_variant)
8014
623
{
8015
623
  proto_item *parameter_item;
8016
623
  proto_tree *parameter_tree;
8017
623
  int         offset = 0;
8018
623
  unsigned    parameter_type, parameter_length, actual_length;
8019
623
  tvbuff_t   *parameter_tvb;
8020
623
  uint8_t     octet;
8021
623
  uint16_t    chg_inf_type = 0xffff;
8022
8023
  /* Dissect all optional parameters while end of message isn't reached */
8024
623
  parameter_type = 0xFF; /* Start-initialization since parameter_type is used for while-condition */
8025
8026
5.02k
  while ((tvb_reported_length_remaining(optional_parameters_tvb, offset)  >= 1) && (parameter_type != PARAM_TYPE_END_OF_OPT_PARAMS)) {
8027
4.80k
    parameter_type = tvb_get_uint8(optional_parameters_tvb, offset);
8028
8029
4.80k
    if (parameter_type != PARAM_TYPE_END_OF_OPT_PARAMS) {
8030
4.63k
      parameter_length = tvb_get_uint8(optional_parameters_tvb, offset + PARAMETER_TYPE_LENGTH);
8031
4.63k
      if (parameter_length + PARAMETER_TYPE_LENGTH + PARAMETER_LENGTH_IND_LENGTH > (unsigned)(tvb_reported_length_remaining(optional_parameters_tvb, offset))) {
8032
318
        proto_tree_add_expert_format_remaining(isup_tree, pinfo, &ei_isup_opt_par_length_err, optional_parameters_tvb, offset,
8033
318
          "Wrong parameter length %u, should be %u",
8034
318
          parameter_length,
8035
318
          tvb_reported_length_remaining(optional_parameters_tvb, offset)- (PARAMETER_TYPE_LENGTH + PARAMETER_LENGTH_IND_LENGTH));
8036
318
        return;
8037
318
      }
8038
8039
4.31k
      parameter_tree = proto_tree_add_subtree_format(isup_tree, optional_parameters_tvb,
8040
4.31k
                                           offset,
8041
4.31k
                                           parameter_length  + PARAMETER_TYPE_LENGTH + PARAMETER_LENGTH_IND_LENGTH,
8042
4.31k
                                           ett_isup_parameter, &parameter_item,
8043
4.31k
                                           "Parameter: (t=%u, l=%u)",
8044
4.31k
                                           parameter_type, parameter_length);
8045
      /* Handle national extensions here */
8046
4.31k
      switch (itu_isup_variant) {
8047
0
        case ISUP_JAPAN_VARIANT:
8048
        /* Fall through */
8049
0
        case ISUP_JAPAN_TTC_VARIANT:
8050
0
          proto_tree_add_uint_format_value(parameter_tree, hf_isup_opt_parameter_type, optional_parameters_tvb, offset, PARAMETER_TYPE_LENGTH,
8051
0
                                     parameter_type,
8052
0
                                     "%u (%s)",
8053
0
                                     parameter_type,
8054
0
                                     val_to_str_ext_const(parameter_type, &japan_isup_parameter_type_value_ext, "unknown"));
8055
0
          proto_item_append_text(parameter_tree, ": %s", val_to_str_ext_const(parameter_type, &japan_isup_parameter_type_value_ext, "Unknown"));
8056
0
          break;
8057
4.30k
        default:
8058
4.30k
          proto_tree_add_uint(parameter_tree, hf_isup_opt_parameter_type, optional_parameters_tvb, offset, PARAMETER_TYPE_LENGTH, parameter_type);
8059
4.30k
          proto_item_append_text(parameter_tree, ": %s", val_to_str_ext_const(parameter_type, &ansi_isup_parameter_type_value_ext, "Unknown"));
8060
4.30k
          break;
8061
8062
4.31k
      }
8063
4.30k
      offset += PARAMETER_TYPE_LENGTH;
8064
8065
4.30k
      octet = tvb_get_uint8(optional_parameters_tvb, offset);
8066
8067
4.30k
      proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, optional_parameters_tvb, offset,
8068
4.30k
                                 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
8069
4.30k
      offset += PARAMETER_LENGTH_IND_LENGTH;
8070
4.30k
      if (octet == 0)
8071
156
        continue;
8072
8073
4.14k
      actual_length = tvb_reported_length_remaining(optional_parameters_tvb, offset);
8074
4.14k
      if (actual_length > 0) {
8075
4.14k
        parameter_tvb = tvb_new_subset_length(optional_parameters_tvb, offset, parameter_length);
8076
4.14k
        switch (parameter_type) {
8077
39
          case PARAM_TYPE_CALL_REF:
8078
39
            dissect_isup_call_reference_parameter(parameter_tvb, parameter_tree, parameter_item);
8079
39
            break;
8080
216
          case PARAM_TYPE_TRANSM_MEDIUM_REQU:
8081
216
            dissect_isup_transmission_medium_requirement_parameter(parameter_tvb, parameter_tree, parameter_item);
8082
216
            break;
8083
85
          case PARAM_TYPE_ACC_TRANSP:
8084
85
            dissect_isup_access_transport_parameter(parameter_tvb, parameter_tree, parameter_item, pinfo);
8085
85
            break;
8086
152
          case PARAM_TYPE_CALLED_PARTY_NR:
8087
152
            dissect_isup_called_party_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8088
152
            break;
8089
160
          case PARAM_TYPE_SUBSQT_NR:
8090
160
            dissect_isup_subsequent_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8091
160
            break;
8092
61
          case PARAM_TYPE_NATURE_OF_CONN_IND:
8093
61
            dissect_isup_nature_of_connection_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8094
61
            break;
8095
64
          case PARAM_TYPE_FORW_CALL_IND:
8096
64
            dissect_isup_forward_call_indicators_parameter(parameter_tvb, pinfo, parameter_item, parameter_tree);
8097
64
            break;
8098
89
          case PARAM_TYPE_OPT_FORW_CALL_IND:
8099
89
            dissect_isup_optional_forward_call_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8100
89
            break;
8101
68
          case PARAM_TYPE_CALLING_PRTY_CATEG:
8102
68
            dissect_isup_calling_partys_category_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
8103
68
            break;
8104
112
          case PARAM_TYPE_CALLING_PARTY_NR:
8105
112
            dissect_isup_calling_party_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8106
112
            break;
8107
190
          case PARAM_TYPE_REDIRECTING_NR:
8108
190
            dissect_isup_redirecting_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8109
190
            break;
8110
109
          case PARAM_TYPE_REDIRECTION_NR:
8111
109
            dissect_isup_redirection_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8112
109
            break;
8113
120
          case PARAM_TYPE_CONNECTION_REQ:
8114
120
            dissect_isup_connection_request_parameter(parameter_tvb, parameter_tree, parameter_item);
8115
120
            break;
8116
73
          case PARAM_TYPE_INFO_REQ_IND:
8117
73
            dissect_isup_information_request_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8118
73
            break;
8119
122
          case PARAM_TYPE_INFO_IND:
8120
122
            dissect_isup_information_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8121
122
            break;
8122
45
          case PARAM_TYPE_CONTINUITY_IND:
8123
45
            dissect_isup_continuity_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8124
45
            break;
8125
59
          case PARAM_TYPE_BACKW_CALL_IND:
8126
59
            dissect_isup_backward_call_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8127
59
            break;
8128
88
          case PARAM_TYPE_CAUSE_INDICATORS:
8129
88
            dissect_isup_cause_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8130
88
            break;
8131
46
          case PARAM_TYPE_REDIRECTION_INFO:
8132
46
            dissect_isup_redirection_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8133
46
            break;
8134
43
          case PARAM_TYPE_CIRC_GRP_SV_MSG_TYPE:
8135
43
            dissect_isup_circuit_group_supervision_message_type_parameter(parameter_tvb, parameter_tree, parameter_item);
8136
43
            break;
8137
39
          case PARAM_TYPE_RANGE_AND_STATUS:
8138
39
            dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8139
39
            break;
8140
40
          case PARAM_TYPE_FACILITY_IND:
8141
40
            dissect_isup_facility_ind_parameter(parameter_tvb, parameter_item);
8142
40
            break;
8143
108
          case PARAM_TYPE_CLSD_USR_GRP_ILOCK_CD:
8144
108
            dissect_isup_closed_user_group_interlock_code_parameter(parameter_tvb, parameter_tree, parameter_item);
8145
108
            break;
8146
30
          case PARAM_TYPE_USER_SERVICE_INFO:
8147
30
            dissect_isup_user_service_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8148
30
            break;
8149
14
          case PARAM_TYPE_SIGNALLING_POINT_CODE:
8150
14
            dissect_isup_signalling_point_code_parameter(parameter_tvb, parameter_tree, parameter_item);
8151
14
            break;
8152
35
          case PARAM_TYPE_USER_TO_USER_INFO:
8153
35
            dissect_isup_user_to_user_information_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8154
35
            break;
8155
35
          case PARAM_TYPE_CONNECTED_NR:
8156
35
            dissect_isup_connected_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8157
35
            break;
8158
27
          case PARAM_TYPE_SUSP_RESUME_IND:
8159
27
            dissect_isup_suspend_resume_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8160
27
            break;
8161
16
          case PARAM_TYPE_TRANSIT_NETW_SELECT:
8162
16
            dissect_isup_transit_network_selection_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8163
16
            break;
8164
32
          case PARAM_TYPE_EVENT_INFO:
8165
32
            dissect_isup_event_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8166
32
            break;
8167
25
          case PARAM_TYPE_CIRC_ASSIGN_MAP:
8168
25
            dissect_isup_circuit_assignment_map_parameter(parameter_tvb, parameter_tree, parameter_item);
8169
25
            break;
8170
76
          case PARAM_TYPE_CIRC_STATE_IND:
8171
76
            dissect_isup_circuit_state_ind_parameter(parameter_tvb, parameter_tree, parameter_item);
8172
76
            break;
8173
24
          case PARAM_TYPE_AUTO_CONG_LEVEL:
8174
24
            dissect_isup_automatic_congestion_level_parameter(parameter_tvb, parameter_tree, parameter_item);
8175
24
            break;
8176
32
          case PARAM_TYPE_ORIG_CALLED_NR:
8177
32
            dissect_isup_original_called_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8178
32
            break;
8179
27
          case PARAM_TYPE_OPT_BACKW_CALL_IND:
8180
27
            dissect_isup_optional_backward_call_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8181
27
            break;
8182
36
          case PARAM_TYPE_USER_TO_USER_IND:
8183
36
            dissect_isup_user_to_user_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8184
36
            break;
8185
20
          case PARAM_TYPE_ORIG_ISC_POINT_CODE:
8186
20
            dissect_isup_original_isc_point_code_parameter(parameter_tvb, parameter_tree, parameter_item);
8187
20
            break;
8188
37
          case PARAM_TYPE_GENERIC_NOTIF_IND:
8189
37
            dissect_isup_generic_notification_indicator_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8190
37
            break;
8191
32
          case PARAM_TYPE_CALL_HIST_INFO :
8192
32
            dissect_isup_call_history_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8193
32
            break;
8194
23
          case PARAM_TYPE_ACC_DELIV_INFO:
8195
23
            dissect_isup_access_delivery_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8196
23
            break;
8197
26
          case PARAM_TYPE_NETW_SPECIFIC_FACLTY:
8198
26
            dissect_isup_network_specific_facility_parameter(parameter_tvb, parameter_tree, parameter_item);
8199
26
            break;
8200
47
          case PARAM_TYPE_USER_SERVICE_INFO_PR:
8201
47
            dissect_isup_user_service_information_prime_parameter(parameter_tvb, parameter_tree, parameter_item);
8202
47
            break;
8203
36
          case PARAM_TYPE_PROPAG_DELAY_COUNTER:
8204
36
            dissect_isup_propagation_delay_counter_parameter(parameter_tvb, parameter_tree, parameter_item);
8205
36
            break;
8206
28
          case PARAM_TYPE_REMOTE_OPERATIONS:
8207
28
            dissect_isup_remote_operations_parameter(parameter_tvb, parameter_tree, parameter_item);
8208
28
            break;
8209
54
          case PARAM_TYPE_SERVICE_ACTIVATION:
8210
54
            dissect_isup_service_activation_parameter(parameter_tvb, parameter_tree, parameter_item);
8211
54
            break;
8212
29
          case PARAM_TYPE_USER_TELESERV_INFO:
8213
29
            dissect_isup_user_teleservice_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8214
29
            break;
8215
63
          case PARAM_TYPE_TRANSM_MEDIUM_USED:
8216
63
            dissect_isup_transmission_medium_used_parameter(parameter_tvb, parameter_tree, parameter_item);
8217
63
            break;
8218
15
          case PARAM_TYPE_CALL_DIV_INFO:
8219
15
            dissect_isup_call_diversion_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8220
15
            break;
8221
23
          case PARAM_TYPE_ECHO_CTRL_INFO:
8222
23
            dissect_isup_echo_control_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8223
23
            break;
8224
9
          case PARAM_TYPE_MSG_COMPAT_INFO:
8225
9
            dissect_isup_message_compatibility_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8226
9
            break;
8227
43
          case PARAM_TYPE_PARAM_COMPAT_INFO:
8228
43
            dissect_isup_parameter_compatibility_information_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8229
43
            break;
8230
89
          case PARAM_TYPE_MLPP_PRECEDENCE:
8231
89
            dissect_isup_mlpp_precedence_parameter(parameter_tvb, parameter_tree, parameter_item);
8232
89
            break;
8233
14
          case PARAM_TYPE_MCID_REQ_IND:
8234
14
            dissect_isup_mcid_request_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8235
14
            break;
8236
22
          case PARAM_TYPE_MCID_RSP_IND:
8237
22
            dissect_isup_mcid_response_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8238
22
            break;
8239
16
          case PARAM_TYPE_HOP_COUNTER:
8240
16
            dissect_isup_hop_counter_parameter(parameter_tvb, parameter_tree, parameter_item);
8241
16
            break;
8242
32
          case PARAM_TYPE_TRANSM_MEDIUM_RQUR_PR:
8243
32
            dissect_isup_transmission_medium_requirement_prime_parameter(parameter_tvb, parameter_tree, parameter_item);
8244
32
            break;
8245
35
          case PARAM_TYPE_LOCATION_NR:
8246
35
            dissect_isup_location_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8247
35
            break;
8248
12
          case PARAM_TYPE_REDIR_NR_RSTRCT:
8249
12
            dissect_isup_redirection_number_restriction_parameter(parameter_tvb, parameter_tree, parameter_item);
8250
12
            break;
8251
15
          case PARAM_TYPE_CALL_TRANS_REF:
8252
15
            dissect_isup_call_transfer_reference_parameter(parameter_tvb, parameter_tree, parameter_item);
8253
15
            break;
8254
8
          case PARAM_TYPE_LOOP_PREV_IND:
8255
8
            dissect_isup_loop_prevention_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8256
8
            break;
8257
22
          case PARAM_TYPE_CALL_TRANS_NR:
8258
22
            dissect_isup_call_transfer_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8259
22
            break;
8260
16
          case PARAM_TYPE_CCSS:
8261
16
            dissect_isup_ccss_parameter(parameter_tvb, parameter_tree, parameter_item);
8262
16
            break;
8263
8
          case PARAM_TYPE_FORW_GVNS:
8264
8
            dissect_isup_forward_gvns_parameter(parameter_tvb, parameter_tree, parameter_item);
8265
8
            break;
8266
13
          case PARAM_TYPE_BACKW_GVNS:
8267
13
            dissect_isup_backward_gvns_parameter(parameter_tvb, parameter_tree, parameter_item);
8268
13
            break;
8269
10
          case PARAM_TYPE_REDIRECT_CAPAB:
8270
10
            dissect_isup_redirect_capability_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
8271
10
            break;
8272
30
          case PARAM_TYPE_NETW_MGMT_CTRL:
8273
30
            dissect_isup_network_management_controls_parameter(parameter_tvb, parameter_tree, parameter_item);
8274
30
            break;
8275
12
          case PARAM_TYPE_CORRELATION_ID:
8276
12
            dissect_isup_correlation_id_parameter(parameter_tvb, parameter_tree, parameter_item);
8277
12
            break;
8278
16
          case PARAM_TYPE_SCF_ID:
8279
16
            dissect_isup_scf_id_parameter(parameter_tvb, parameter_tree, parameter_item);
8280
16
            break;
8281
20
          case PARAM_TYPE_CALL_DIV_TREAT_IND:
8282
20
            dissect_isup_call_diversion_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8283
20
            break;
8284
11
          case PARAM_TYPE_CALLED_IN_NR:
8285
11
            dissect_isup_called_in_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8286
11
            break;
8287
16
          case PARAM_TYPE_CALL_OFF_TREAT_IND:
8288
16
            dissect_isup_call_offering_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8289
16
            break;
8290
8
          case PARAM_TYPE_CHARGED_PARTY_IDENT:
8291
8
            dissect_isup_charged_party_identification_parameter(parameter_tvb, parameter_tree, parameter_item);
8292
8
            break;
8293
14
          case PARAM_TYPE_CONF_TREAT_IND:
8294
14
            dissect_isup_conference_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8295
14
            break;
8296
12
          case PARAM_TYPE_DISPLAY_INFO:
8297
12
            dissect_isup_display_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8298
12
            break;
8299
18
          case PARAM_TYPE_UID_ACTION_IND:
8300
18
            dissect_isup_uid_action_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8301
18
            break;
8302
8
          case PARAM_TYPE_UID_CAPAB_IND:
8303
8
            dissect_isup_uid_capability_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8304
8
            break;
8305
8
          case PARAM_TYPE_REDIRECT_COUNTER:
8306
8
            dissect_isup_redirect_counter_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
8307
8
            break;
8308
13
          case PARAM_TYPE_COLLECT_CALL_REQ:
8309
13
            dissect_isup_collect_call_request_parameter(parameter_tvb, parameter_tree, parameter_item);
8310
13
            break;
8311
23
          case PARAM_TYPE_GENERIC_NR:
8312
23
            dissect_isup_generic_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8313
23
            break;
8314
7
          case PARAM_TYPE_GENERIC_DIGITS:
8315
7
            dissect_isup_generic_digits_parameter(parameter_tvb, parameter_tree, parameter_item);
8316
7
            break;
8317
23
          case PARAM_TYPE_APPLICATION_TRANS:
8318
23
            dissect_isup_application_transport_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8319
23
            break;
8320
8321
576
          default:
8322
576
            switch (itu_isup_variant) {
8323
0
              case ISUP_JAPAN_VARIANT:
8324
              /* Fall through */
8325
0
              case ISUP_JAPAN_TTC_VARIANT:
8326
0
                switch (parameter_type) {
8327
0
                  case JAPAN_ISUP_PARAM_CALLED_DIRECTORY_NUMBER:
8328
0
                    dissect_japan_isup_called_dir_num(parameter_tvb, pinfo, parameter_tree, parameter_item);
8329
0
                    break;
8330
0
                  case JAPAN_ISUP_PARAM_REDIRECT_FORWARD_INF: /* 0x8B */
8331
0
                    dissect_japan_isup_redirect_fwd_inf(parameter_tvb, pinfo, parameter_tree, parameter_item);
8332
0
                    break;
8333
0
                  case JAPAN_ISUP_PARAM_REDIRECT_BACKWARD_INF:  /* 0x8C */
8334
0
                    dissect_japan_isup_redirect_backw_inf(parameter_tvb, pinfo, parameter_tree, parameter_item);
8335
0
                    break;
8336
0
                  case JAPAN_ISUP_PARAM_EMERGENCY_CALL_IND: /* D7 */
8337
0
                    dissect_japan_isup_emergency_call_ind(parameter_tvb, parameter_tree, parameter_item);
8338
0
                    break;
8339
0
                  case JAPAN_ISUP_PARAM_EMERGENCY_CALL_INF_IND: /* EC */
8340
0
                    dissect_japan_isup_emergency_call_inf_ind(parameter_tvb, parameter_tree, parameter_item);
8341
0
                    break;
8342
0
                  case JAPAN_ISUP_PARAM_NETWORK_POI_CA: /* EE */
8343
0
                    dissect_japan_isup_network_poi_cad(parameter_tvb, pinfo, parameter_tree, parameter_item);
8344
0
                    break;
8345
0
                  case JAPAN_ISUP_PARAM_TYPE_CARRIER_INFO: /* 241 F1 */
8346
0
                    dissect_japan_isup_carrier_information(parameter_tvb, pinfo, parameter_tree, parameter_item);
8347
0
                    break;
8348
0
                  case JAPAN_ISUP_PARAM_CHARGE_INF_DELAY:  /* 242 F2 */
8349
0
                    dissect_japan_isup_charge_inf_delay(parameter_tvb, parameter_tree, parameter_item);
8350
0
                    break;
8351
0
                  case JAPAN_ISUP_PARAM_TYPE_ADDITONAL_USER_CAT: /* F3 */
8352
0
                    dissect_japan_isup_additonal_user_cat(parameter_tvb, pinfo, parameter_tree, parameter_item);
8353
0
                    break;
8354
0
                  case JAPAN_ISUP_PARAM_REASON_FOR_CLIP_FAIL: /* F5 */
8355
0
                    dissect_japan_isup_reason_for_clip_fail(parameter_tvb, parameter_tree, parameter_item);
8356
0
                    break;
8357
0
                  case JAPAN_ISUP_PARAM_TYPE_CONTRACTOR_NUMBER: /* F9 */
8358
0
                    dissect_japan_isup_contractor_number(parameter_tvb, pinfo, parameter_tree, parameter_item);
8359
0
                    break;
8360
0
                  case JAPAN_ISUP_PARAM_TYPE_CHARGE_INF_TYPE: /* FA */
8361
0
                    chg_inf_type = dissect_japan_chg_inf_type(parameter_tvb, parameter_tree, parameter_item);
8362
0
                    break;
8363
0
                  case JAPAN_ISUP_PARAM_TYPE_CHARGE_INF:
8364
0
                    dissect_japan_chg_inf_param(parameter_tvb, pinfo, parameter_tree, parameter_item, chg_inf_type);
8365
0
                    break;
8366
0
                  case JAPAN_ISUP_PARAM_TYPE_CHARGE_AREA_INFO:
8367
0
                    dissect_japan_isup_charge_area_info(parameter_tvb, pinfo, parameter_tree, parameter_item);
8368
0
                    break;
8369
0
                  default:
8370
0
                    dissect_isup_unknown_parameter(parameter_tvb, parameter_tree, parameter_item);
8371
0
                    break;
8372
0
                }
8373
0
                break;
8374
576
              default:
8375
576
                dissect_isup_unknown_parameter(parameter_tvb, parameter_tree, parameter_item);
8376
576
                break;
8377
576
            }
8378
548
            break;
8379
4.14k
        }
8380
8381
4.07k
        offset += MIN(parameter_length, actual_length);
8382
4.07k
      }
8383
8384
4.14k
    }
8385
172
    else {
8386
      /* End of optional parameters is reached */
8387
172
      proto_tree_add_uint_format(isup_tree, hf_isup_parameter_type, optional_parameters_tvb , offset, PARAMETER_TYPE_LENGTH,
8388
172
                                 parameter_type, "End of optional parameters (%u)", parameter_type);
8389
172
    }
8390
4.80k
  }
8391
623
}
8392
8393
/* ------------------------------------------------------------------
8394
  Dissector all ANSI optional parameters
8395
  TODO: Actually make this dissect ANSI :) - It's still plain old ITU for now
8396
*/
8397
static void
8398
dissect_ansi_isup_optional_parameter(tvbuff_t *optional_parameters_tvb, packet_info *pinfo, proto_tree *isup_tree, uint8_t itu_isup_variant)
8399
0
{ proto_item *parameter_item;
8400
0
  proto_tree *parameter_tree;
8401
0
  int         offset = 0;
8402
0
  unsigned    parameter_type, parameter_length, actual_length;
8403
0
  tvbuff_t   *parameter_tvb;
8404
0
  uint8_t     octet;
8405
8406
  /* Dissect all optional parameters while end of message isn't reached */
8407
0
  parameter_type = 0xFF; /* Start-initialization since parameter_type is used for while-condition */
8408
8409
0
  while ((tvb_reported_length_remaining(optional_parameters_tvb, offset)  >= 1) && (parameter_type != PARAM_TYPE_END_OF_OPT_PARAMS)) {
8410
0
    parameter_type = tvb_get_uint8(optional_parameters_tvb, offset);
8411
8412
0
    if (parameter_type != PARAM_TYPE_END_OF_OPT_PARAMS) {
8413
0
      parameter_length = tvb_get_uint8(optional_parameters_tvb, offset + PARAMETER_TYPE_LENGTH);
8414
8415
0
      parameter_tree = proto_tree_add_subtree_format(isup_tree, optional_parameters_tvb,
8416
0
                                           offset, parameter_length  + PARAMETER_TYPE_LENGTH + PARAMETER_LENGTH_IND_LENGTH,
8417
0
                                           ett_isup_parameter, &parameter_item, "Parameter: (t=%u, l=%u): %s",
8418
0
                                           parameter_type, parameter_length, val_to_str_ext_const(parameter_type, &ansi_isup_parameter_type_value_ext, "Unknown"));
8419
0
      proto_tree_add_uint(parameter_tree, hf_isup_opt_parameter_type, optional_parameters_tvb, offset,
8420
0
                                 PARAMETER_TYPE_LENGTH, parameter_type);
8421
0
      offset += PARAMETER_TYPE_LENGTH;
8422
8423
0
      octet = tvb_get_uint8(optional_parameters_tvb, offset);
8424
8425
0
      proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, optional_parameters_tvb, offset,
8426
0
                                 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
8427
0
      offset += PARAMETER_LENGTH_IND_LENGTH;
8428
0
      if (octet == 0)
8429
0
        continue;
8430
8431
0
      actual_length = tvb_reported_length_remaining(optional_parameters_tvb, offset);
8432
0
      if (actual_length > 0) {
8433
0
        parameter_tvb = tvb_new_subset_length(optional_parameters_tvb, offset, parameter_length);
8434
0
        switch (parameter_type) {
8435
0
          case PARAM_TYPE_CALL_REF:
8436
0
            dissect_isup_call_reference_parameter(parameter_tvb, parameter_tree, parameter_item);
8437
0
            break;
8438
0
          case PARAM_TYPE_TRANSM_MEDIUM_REQU:
8439
0
            dissect_isup_transmission_medium_requirement_parameter(parameter_tvb, parameter_tree, parameter_item);
8440
0
            break;
8441
0
          case PARAM_TYPE_ACC_TRANSP:
8442
0
            dissect_isup_access_transport_parameter(parameter_tvb, parameter_tree, parameter_item, pinfo);
8443
0
            break;
8444
0
          case PARAM_TYPE_CALLED_PARTY_NR:
8445
0
            dissect_isup_called_party_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8446
0
            break;
8447
0
          case PARAM_TYPE_SUBSQT_NR:
8448
0
            dissect_isup_subsequent_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8449
0
            break;
8450
0
          case PARAM_TYPE_NATURE_OF_CONN_IND:
8451
0
            dissect_isup_nature_of_connection_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8452
0
            break;
8453
0
          case PARAM_TYPE_FORW_CALL_IND:
8454
0
            dissect_isup_forward_call_indicators_parameter(parameter_tvb, pinfo, parameter_item, parameter_tree);
8455
0
            break;
8456
0
          case PARAM_TYPE_OPT_FORW_CALL_IND:
8457
0
            dissect_isup_optional_forward_call_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8458
0
            break;
8459
0
          case PARAM_TYPE_CALLING_PRTY_CATEG:
8460
0
            dissect_isup_calling_partys_category_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
8461
0
            break;
8462
0
          case PARAM_TYPE_CALLING_PARTY_NR:
8463
0
            dissect_isup_calling_party_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8464
0
            break;
8465
0
          case PARAM_TYPE_REDIRECTING_NR:
8466
0
            dissect_isup_redirecting_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8467
0
            break;
8468
0
          case PARAM_TYPE_REDIRECTION_NR:
8469
0
            dissect_isup_redirection_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8470
0
            break;
8471
0
          case PARAM_TYPE_CONNECTION_REQ:
8472
0
            dissect_isup_connection_request_parameter(parameter_tvb, parameter_tree, parameter_item);
8473
0
            break;
8474
0
          case PARAM_TYPE_INFO_REQ_IND:
8475
0
            dissect_isup_information_request_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8476
0
            break;
8477
0
          case PARAM_TYPE_INFO_IND:
8478
0
            dissect_isup_information_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8479
0
            break;
8480
0
          case PARAM_TYPE_CONTINUITY_IND:
8481
0
            dissect_isup_continuity_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8482
0
            break;
8483
0
          case PARAM_TYPE_BACKW_CALL_IND:
8484
0
            dissect_ansi_isup_backward_call_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8485
0
            break;
8486
0
          case PARAM_TYPE_CAUSE_INDICATORS:
8487
0
            dissect_ansi_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8488
0
            break;
8489
0
          case PARAM_TYPE_REDIRECTION_INFO:
8490
0
            dissect_isup_redirection_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8491
0
            break;
8492
0
          case PARAM_TYPE_CIRC_GRP_SV_MSG_TYPE:
8493
0
            dissect_isup_circuit_group_supervision_message_type_parameter(parameter_tvb, parameter_tree, parameter_item);
8494
0
            break;
8495
0
          case PARAM_TYPE_RANGE_AND_STATUS:
8496
0
            dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8497
0
            break;
8498
0
          case PARAM_TYPE_FACILITY_IND:
8499
0
            dissect_isup_facility_ind_parameter(parameter_tvb, parameter_item);
8500
0
            break;
8501
0
          case PARAM_TYPE_CLSD_USR_GRP_ILOCK_CD:
8502
0
            dissect_isup_closed_user_group_interlock_code_parameter(parameter_tvb, parameter_tree, parameter_item);
8503
0
            break;
8504
0
          case PARAM_TYPE_USER_SERVICE_INFO:
8505
0
            dissect_isup_user_service_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8506
0
            break;
8507
0
          case PARAM_TYPE_SIGNALLING_POINT_CODE:
8508
0
            dissect_isup_signalling_point_code_parameter(parameter_tvb, parameter_tree, parameter_item);
8509
0
            break;
8510
0
          case PARAM_TYPE_USER_TO_USER_INFO:
8511
0
            dissect_isup_user_to_user_information_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8512
0
            break;
8513
0
          case PARAM_TYPE_CONNECTED_NR:
8514
0
            dissect_isup_connected_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8515
0
            break;
8516
0
          case PARAM_TYPE_SUSP_RESUME_IND:
8517
0
            dissect_isup_suspend_resume_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8518
0
            break;
8519
0
          case PARAM_TYPE_TRANSIT_NETW_SELECT:
8520
0
            dissect_ansi_isup_transit_network_selection_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8521
0
            break;
8522
0
          case PARAM_TYPE_EVENT_INFO:
8523
0
            dissect_isup_event_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8524
0
            break;
8525
0
          case PARAM_TYPE_CIRC_ASSIGN_MAP:
8526
0
            dissect_isup_circuit_assignment_map_parameter(parameter_tvb, parameter_tree, parameter_item);
8527
0
            break;
8528
0
          case PARAM_TYPE_CIRC_STATE_IND:
8529
0
            dissect_isup_circuit_state_ind_parameter(parameter_tvb, parameter_tree, parameter_item);
8530
0
            break;
8531
0
          case PARAM_TYPE_AUTO_CONG_LEVEL:
8532
0
            dissect_isup_automatic_congestion_level_parameter(parameter_tvb, parameter_tree, parameter_item);
8533
0
            break;
8534
0
          case PARAM_TYPE_ORIG_CALLED_NR:
8535
0
            dissect_isup_original_called_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8536
0
            break;
8537
0
          case PARAM_TYPE_OPT_BACKW_CALL_IND:
8538
0
            dissect_isup_optional_backward_call_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8539
0
            break;
8540
0
          case PARAM_TYPE_USER_TO_USER_IND:
8541
0
            dissect_isup_user_to_user_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8542
0
            break;
8543
0
          case PARAM_TYPE_ORIG_ISC_POINT_CODE:
8544
0
            dissect_isup_original_isc_point_code_parameter(parameter_tvb, parameter_tree, parameter_item);
8545
0
            break;
8546
0
          case PARAM_TYPE_GENERIC_NOTIF_IND:
8547
0
            dissect_isup_generic_notification_indicator_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8548
0
            break;
8549
0
          case PARAM_TYPE_CALL_HIST_INFO :
8550
0
            dissect_isup_call_history_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8551
0
            break;
8552
0
          case PARAM_TYPE_ACC_DELIV_INFO:
8553
0
            dissect_isup_access_delivery_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8554
0
            break;
8555
0
          case PARAM_TYPE_NETW_SPECIFIC_FACLTY:
8556
0
            dissect_isup_network_specific_facility_parameter(parameter_tvb, parameter_tree, parameter_item);
8557
0
            break;
8558
0
          case PARAM_TYPE_USER_SERVICE_INFO_PR:
8559
0
            dissect_isup_user_service_information_prime_parameter(parameter_tvb, parameter_tree, parameter_item);
8560
0
            break;
8561
0
          case PARAM_TYPE_PROPAG_DELAY_COUNTER:
8562
0
            dissect_isup_propagation_delay_counter_parameter(parameter_tvb, parameter_tree, parameter_item);
8563
0
            break;
8564
0
          case PARAM_TYPE_REMOTE_OPERATIONS:
8565
0
            dissect_isup_remote_operations_parameter(parameter_tvb, parameter_tree, parameter_item);
8566
0
            break;
8567
0
          case PARAM_TYPE_SERVICE_ACTIVATION:
8568
0
            dissect_isup_service_activation_parameter(parameter_tvb, parameter_tree, parameter_item);
8569
0
            break;
8570
0
          case PARAM_TYPE_USER_TELESERV_INFO:
8571
0
            dissect_isup_user_teleservice_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8572
0
            break;
8573
0
          case PARAM_TYPE_TRANSM_MEDIUM_USED:
8574
0
            dissect_isup_transmission_medium_used_parameter(parameter_tvb, parameter_tree, parameter_item);
8575
0
            break;
8576
0
          case PARAM_TYPE_CALL_DIV_INFO:
8577
0
            dissect_isup_call_diversion_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8578
0
            break;
8579
0
          case PARAM_TYPE_ECHO_CTRL_INFO:
8580
0
            dissect_isup_echo_control_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8581
0
            break;
8582
0
          case PARAM_TYPE_MSG_COMPAT_INFO:
8583
0
            dissect_isup_message_compatibility_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8584
0
            break;
8585
0
          case PARAM_TYPE_PARAM_COMPAT_INFO:
8586
0
            dissect_isup_parameter_compatibility_information_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8587
0
            break;
8588
0
          case PARAM_TYPE_MLPP_PRECEDENCE:
8589
0
            dissect_isup_mlpp_precedence_parameter(parameter_tvb, parameter_tree, parameter_item);
8590
0
            break;
8591
0
          case PARAM_TYPE_MCID_REQ_IND:
8592
0
            dissect_isup_mcid_request_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8593
0
            break;
8594
0
          case PARAM_TYPE_MCID_RSP_IND:
8595
0
            dissect_isup_mcid_response_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8596
0
            break;
8597
0
          case PARAM_TYPE_HOP_COUNTER:
8598
0
            dissect_isup_hop_counter_parameter(parameter_tvb, parameter_tree, parameter_item);
8599
0
            break;
8600
0
          case PARAM_TYPE_ORIG_LINE_INFO:
8601
0
            dissect_isup_orig_line_info_parameter(parameter_tvb, parameter_tree, parameter_item);
8602
0
            break;
8603
0
          case PARAM_TYPE_TRANSM_MEDIUM_RQUR_PR:
8604
0
            dissect_isup_transmission_medium_requirement_prime_parameter(parameter_tvb, parameter_tree, parameter_item);
8605
0
            break;
8606
0
          case PARAM_TYPE_LOCATION_NR:
8607
0
            dissect_isup_location_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8608
0
            break;
8609
0
          case PARAM_TYPE_REDIR_NR_RSTRCT:
8610
0
            dissect_isup_redirection_number_restriction_parameter(parameter_tvb, parameter_tree, parameter_item);
8611
0
            break;
8612
0
          case PARAM_TYPE_CALL_TRANS_REF:
8613
0
            dissect_isup_call_transfer_reference_parameter(parameter_tvb, parameter_tree, parameter_item);
8614
0
            break;
8615
0
          case PARAM_TYPE_LOOP_PREV_IND:
8616
0
            dissect_isup_loop_prevention_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8617
0
            break;
8618
0
          case PARAM_TYPE_CALL_TRANS_NR:
8619
0
            dissect_isup_call_transfer_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8620
0
            break;
8621
0
          case PARAM_TYPE_CCSS:
8622
0
            dissect_isup_ccss_parameter(parameter_tvb, parameter_tree, parameter_item);
8623
0
            break;
8624
0
          case PARAM_TYPE_FORW_GVNS:
8625
0
            dissect_isup_forward_gvns_parameter(parameter_tvb, parameter_tree, parameter_item);
8626
0
            break;
8627
0
          case PARAM_TYPE_BACKW_GVNS:
8628
0
            dissect_isup_backward_gvns_parameter(parameter_tvb, parameter_tree, parameter_item);
8629
0
            break;
8630
0
          case PARAM_TYPE_REDIRECT_CAPAB:
8631
0
            dissect_isup_redirect_capability_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
8632
0
            break;
8633
0
          case PARAM_TYPE_NETW_MGMT_CTRL:
8634
0
            dissect_isup_network_management_controls_parameter(parameter_tvb, parameter_tree, parameter_item);
8635
0
            break;
8636
0
          case PARAM_TYPE_CORRELATION_ID:
8637
0
            dissect_isup_correlation_id_parameter(parameter_tvb, parameter_tree, parameter_item);
8638
0
            break;
8639
0
          case PARAM_TYPE_SCF_ID:
8640
0
            dissect_isup_scf_id_parameter(parameter_tvb, parameter_tree, parameter_item);
8641
0
            break;
8642
0
          case PARAM_TYPE_CALL_DIV_TREAT_IND:
8643
0
            dissect_isup_call_diversion_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8644
0
            break;
8645
0
          case PARAM_TYPE_CALLED_IN_NR:
8646
0
            dissect_isup_called_in_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8647
0
            break;
8648
0
          case PARAM_TYPE_CALL_OFF_TREAT_IND:
8649
0
            dissect_isup_call_offering_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8650
0
            break;
8651
0
          case PARAM_TYPE_CHARGED_PARTY_IDENT:
8652
0
            dissect_isup_charged_party_identification_parameter(parameter_tvb, parameter_tree, parameter_item);
8653
0
            break;
8654
0
          case PARAM_TYPE_CONF_TREAT_IND:
8655
0
            dissect_isup_conference_treatment_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8656
0
            break;
8657
0
          case PARAM_TYPE_DISPLAY_INFO:
8658
0
            dissect_isup_display_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8659
0
            break;
8660
0
          case PARAM_TYPE_UID_ACTION_IND:
8661
0
            dissect_isup_uid_action_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8662
0
            break;
8663
0
          case PARAM_TYPE_UID_CAPAB_IND:
8664
0
            dissect_isup_uid_capability_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8665
0
            break;
8666
0
          case PARAM_TYPE_REDIRECT_COUNTER:
8667
0
            dissect_isup_redirect_counter_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
8668
0
            break;
8669
0
          case PARAM_TYPE_COLLECT_CALL_REQ:
8670
0
            dissect_isup_collect_call_request_parameter(parameter_tvb, parameter_tree, parameter_item);
8671
0
            break;
8672
0
          case PARAM_TYPE_CALLING_GEODETIC_LOCATION:
8673
0
            dissect_isup_calling_geodetic_location_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8674
0
            break;
8675
0
          case PARAM_TYPE_GENERIC_NR:
8676
0
            dissect_isup_generic_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8677
0
            break;
8678
0
          case PARAM_TYPE_JURISDICTION:
8679
0
            dissect_isup_jurisdiction_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8680
0
            break;
8681
0
          case PARAM_TYPE_GENERIC_NAME:
8682
0
            dissect_isup_generic_name_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8683
0
            break;
8684
0
          case PARAM_TYPE_GENERIC_DIGITS:
8685
0
            dissect_isup_generic_digits_parameter(parameter_tvb, parameter_tree, parameter_item);
8686
0
            break;
8687
0
          case PARAM_TYPE_CHARGE_NR:
8688
0
            dissect_isup_charge_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8689
0
            break;
8690
0
          case PARAM_TYPE_APPLICATION_TRANS:
8691
0
            dissect_isup_application_transport_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8692
0
            break;
8693
0
          case ANSI_ISUP_PARAM_TYPE_CARRIER_ID:
8694
0
            dissect_ansi_isup_param_carrier_id(parameter_tvb, pinfo, parameter_tree, parameter_item);
8695
0
            break;
8696
0
          default:
8697
0
            dissect_isup_unknown_parameter(parameter_tvb, parameter_tree, parameter_item);
8698
0
            break;
8699
0
        }
8700
8701
0
        offset += MIN(parameter_length, actual_length);
8702
0
      }
8703
8704
0
    }
8705
0
    else {
8706
      /* End of optional parameters is reached */
8707
0
      proto_tree_add_uint_format(isup_tree, hf_isup_parameter_type, optional_parameters_tvb , offset,
8708
0
                                 PARAMETER_TYPE_LENGTH, parameter_type, "End of optional parameters (%u)", parameter_type);
8709
0
    }
8710
0
  }
8711
0
}
8712
8713
/* ------------------------------------------------------------------ */
8714
/* Dissectors for all used message types                              */
8715
/* Called by dissect_isup_message(),                                  */
8716
/* call parameter dissectors in order of mandatory parameters         */
8717
/* (since not labeled)                                                */
8718
/* ------------------------------------------------------------------
8719
  Dissector Message Type Circuit Validation Test Response
8720
 */
8721
static int
8722
dissect_ansi_isup_circuit_validation_test_resp_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
8723
0
{
8724
0
  proto_item *parameter_item;
8725
0
  proto_tree *parameter_tree;
8726
0
  tvbuff_t   *parameter_tvb;
8727
0
  int         offset = 0;
8728
0
  int         parameter_type;
8729
8730
  /* Do stuff for first mandatory fixed parameter: CVR Response Indicator */
8731
0
  parameter_type = ANSI_ISUP_PARAM_TYPE_CVR_RESP_IND;
8732
0
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset, CVR_RESP_IND_LENGTH,
8733
0
                                    ett_isup_parameter, &parameter_item, "CVR Response Indicator");
8734
8735
0
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type,
8736
0
                             "%u (%s)",
8737
0
                             parameter_type,
8738
0
                             val_to_str_ext_const(parameter_type, &isup_parameter_type_value_ext, "CVR Response Indicator"));
8739
8740
0
  tvb_ensure_captured_length_remaining(message_tvb, offset);
8741
8742
0
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, CVR_RESP_IND_LENGTH);
8743
0
  dissect_isup_cvr_response_ind_parameter(parameter_tvb, parameter_tree, parameter_item);
8744
0
  offset += CVR_RESP_IND_LENGTH;
8745
8746
  /* Do stuff for second mandatory fixed parameter: CG Characteristics Indicator */
8747
0
  parameter_type = ANSI_ISUP_PARAM_TYPE_CG_CHAR_IND;
8748
0
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8749
0
                                       CG_CHAR_IND_LENGTH, ett_isup_parameter, &parameter_item,
8750
0
                                       "Circuit Group Characteristics Indicators");
8751
0
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type,
8752
0
                             "%u (%s)",
8753
0
                             parameter_type,
8754
0
                             val_to_str_ext_const(parameter_type, &isup_parameter_type_value_ext, "Circuit Group Characters"));
8755
0
  tvb_ensure_captured_length_remaining(message_tvb, offset);
8756
0
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, CG_CHAR_IND_LENGTH);
8757
0
  dissect_isup_circuit_group_char_ind_parameter(parameter_tvb, parameter_tree, parameter_item);
8758
0
  offset += CG_CHAR_IND_LENGTH;
8759
8760
0
  return offset;
8761
0
}
8762
8763
/* ------------------------------------------------------------------
8764
  Dissector Message Type Circuit Reservation
8765
 */
8766
static int
8767
dissect_ansi_isup_circuit_reservation_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
8768
0
{ proto_item *parameter_item;
8769
0
  proto_tree *parameter_tree;
8770
0
  tvbuff_t   *parameter_tvb;
8771
0
  int         offset = 0;
8772
0
  int         parameter_type;
8773
8774
  /* Do stuff for mandatory fixed parameter: Nature of Connection Indicators */
8775
0
  parameter_type = PARAM_TYPE_NATURE_OF_CONN_IND;
8776
0
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8777
0
                                       NATURE_OF_CONNECTION_IND_LENGTH, ett_isup_parameter, &parameter_item,
8778
0
                                       "Nature of Connection Indicators");
8779
0
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8780
0
  tvb_ensure_captured_length_remaining(message_tvb, offset);
8781
0
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, NATURE_OF_CONNECTION_IND_LENGTH);
8782
0
  dissect_isup_nature_of_connection_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8783
0
  offset += NATURE_OF_CONNECTION_IND_LENGTH;
8784
8785
0
  return offset;
8786
0
}
8787
8788
/* ------------------------------------------------------------------
8789
  Dissector Message Type Initial address message
8790
 */
8791
static int
8792
dissect_isup_initial_address_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree, uint8_t itu_isup_variant)
8793
120
{ proto_item *parameter_item;
8794
120
  proto_tree *parameter_tree;
8795
120
  tvbuff_t   *parameter_tvb;
8796
120
  int         offset = 0;
8797
120
  int         parameter_type, parameter_pointer, parameter_length;
8798
8799
  /* Do stuff for first mandatory fixed parameter: Nature of Connection Indicators */
8800
120
  parameter_type = PARAM_TYPE_NATURE_OF_CONN_IND;
8801
120
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8802
120
                                       NATURE_OF_CONNECTION_IND_LENGTH, ett_isup_parameter, &parameter_item,
8803
120
                                       "Nature of Connection Indicators");
8804
120
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8805
120
  tvb_ensure_captured_length_remaining(message_tvb, offset);
8806
120
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, NATURE_OF_CONNECTION_IND_LENGTH);
8807
120
  dissect_isup_nature_of_connection_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8808
120
  offset += NATURE_OF_CONNECTION_IND_LENGTH;
8809
8810
  /* Do stuff for 2nd mandatory fixed parameter: Forward Call Indicators */
8811
120
  parameter_type =  PARAM_TYPE_FORW_CALL_IND;
8812
120
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8813
120
                                       FORWARD_CALL_IND_LENGTH, ett_isup_parameter, &parameter_item,
8814
120
                                       "Forward Call Indicators");
8815
120
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8816
120
  tvb_ensure_captured_length_remaining(message_tvb, offset);
8817
120
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, FORWARD_CALL_IND_LENGTH);
8818
120
  dissect_isup_forward_call_indicators_parameter(parameter_tvb, pinfo, parameter_item, parameter_tree);
8819
120
  offset +=  FORWARD_CALL_IND_LENGTH;
8820
8821
  /* Do stuff for 3nd mandatory fixed parameter: Calling party's category */
8822
120
  parameter_type = PARAM_TYPE_CALLING_PRTY_CATEG;
8823
120
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8824
120
                                       CALLING_PRTYS_CATEGORY_LENGTH,
8825
120
                                        ett_isup_parameter, &parameter_item,
8826
120
                                       "Calling Party's category");
8827
120
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8828
120
  tvb_ensure_captured_length_remaining(message_tvb, offset);
8829
120
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, CALLING_PRTYS_CATEGORY_LENGTH);
8830
120
  dissect_isup_calling_partys_category_parameter(parameter_tvb, parameter_tree, parameter_item, itu_isup_variant);
8831
120
  offset += CALLING_PRTYS_CATEGORY_LENGTH;
8832
8833
120
  switch (isup_standard) {
8834
120
    case ITU_STANDARD:
8835
      /* If ITU, do stuff for 4th mandatory fixed parameter: Transmission medium requirement */
8836
120
      parameter_type = PARAM_TYPE_TRANSM_MEDIUM_REQU;
8837
120
      parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8838
120
                                           TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH,
8839
120
                                           ett_isup_parameter, &parameter_item,
8840
120
                                           "Transmission medium requirement");
8841
120
      proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8842
120
      tvb_ensure_captured_length_remaining(message_tvb, offset);
8843
120
      parameter_tvb = tvb_new_subset_length(message_tvb,
8844
120
                                     offset,
8845
120
                                     TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH);
8846
120
      dissect_isup_transmission_medium_requirement_parameter(parameter_tvb, parameter_tree, parameter_item);
8847
120
      offset += TRANSMISSION_MEDIUM_REQUIREMENT_LENGTH;
8848
120
      break;
8849
0
    case ANSI_STANDARD:
8850
      /* If ANSI, do stuff for the first mandatory variable parameter, USER_SERVICE_INFORMATION */
8851
0
      parameter_type = PARAM_TYPE_USER_SERVICE_INFO;
8852
0
      parameter_pointer = tvb_get_uint8(message_tvb, offset);
8853
0
      parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);
8854
0
      parameter_tree    = proto_tree_add_subtree(isup_tree, message_tvb,
8855
0
                                              offset +  parameter_pointer,
8856
0
                                              parameter_length + PARAMETER_LENGTH_IND_LENGTH,
8857
0
                                               ett_isup_parameter, &parameter_item,
8858
0
                                              "User Service Information");
8859
0
      proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8860
0
      proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
8861
0
                                 PARAMETER_POINTER_LENGTH, parameter_pointer);
8862
0
      proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
8863
0
                                 PARAMETER_LENGTH_IND_LENGTH, parameter_length);
8864
0
      tvb_ensure_captured_length_remaining(message_tvb, offset);
8865
0
      parameter_tvb = tvb_new_subset_length(message_tvb,
8866
0
                                     offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
8867
0
                                     parameter_length);
8868
0
      dissect_isup_user_service_information_parameter(parameter_tvb, parameter_tree, parameter_item);
8869
0
      offset += PARAMETER_POINTER_LENGTH;
8870
0
      break;
8871
120
  }
8872
8873
  /* Do stuff for mandatory variable parameter Called party number */
8874
120
  parameter_type = PARAM_TYPE_CALLED_PARTY_NR;
8875
120
  parameter_pointer = tvb_get_uint8(message_tvb, offset);
8876
120
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);
8877
8878
120
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
8879
120
                                       offset +  parameter_pointer,
8880
120
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
8881
120
                                        ett_isup_parameter, &parameter_item,
8882
120
                                       "Called Party Number");
8883
120
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8884
120
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
8885
120
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
8886
120
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
8887
120
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
8888
120
  tvb_ensure_captured_length_remaining(message_tvb, offset);
8889
120
  parameter_tvb = tvb_new_subset_length(message_tvb,
8890
120
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
8891
120
                                 parameter_length);
8892
120
  dissect_isup_called_party_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8893
120
  offset += PARAMETER_POINTER_LENGTH;
8894
8895
120
  return offset;
8896
120
}
8897
8898
/* ------------------------------------------------------------------
8899
  Dissector Message Type subsequent address message
8900
 */
8901
static int dissect_isup_subsequent_address_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
8902
14
{ proto_item *parameter_item;
8903
14
  proto_tree *parameter_tree;
8904
14
  tvbuff_t   *parameter_tvb;
8905
14
  int         offset = 0;
8906
14
  int         parameter_type, parameter_pointer, parameter_length;
8907
8908
  /* Do stuff for mandatory variable parameter Subsequent number */
8909
14
  parameter_type = PARAM_TYPE_SUBSQT_NR;
8910
8911
14
  parameter_pointer = tvb_get_uint8(message_tvb, offset);
8912
14
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);
8913
8914
14
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
8915
14
                                       offset +  parameter_pointer,
8916
14
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
8917
14
                                        ett_isup_parameter, &parameter_item,
8918
14
                                       "Subsequent Number");
8919
14
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8920
14
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
8921
14
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
8922
14
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
8923
14
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
8924
14
  tvb_ensure_captured_length_remaining(message_tvb, offset);
8925
14
  parameter_tvb = tvb_new_subset_length(message_tvb,
8926
14
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
8927
14
                                 parameter_length);
8928
14
  dissect_isup_subsequent_number_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
8929
14
  offset += PARAMETER_POINTER_LENGTH;
8930
8931
14
  return offset;
8932
14
}
8933
8934
/* ------------------------------------------------------------------
8935
  Dissector Message Type Information request message
8936
 */
8937
static int
8938
dissect_isup_information_request_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
8939
65
{ proto_item *parameter_item;
8940
65
  proto_tree *parameter_tree;
8941
65
  tvbuff_t   *parameter_tvb;
8942
65
  int         offset = 0;
8943
65
  int         parameter_type;
8944
8945
  /* Do stuff for first mandatory fixed parameter: Information request indicators*/
8946
65
  parameter_type = PARAM_TYPE_INFO_REQ_IND;
8947
65
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8948
65
                                       INFO_REQUEST_IND_LENGTH,
8949
65
                                        ett_isup_parameter, &parameter_item,
8950
65
                                       "Information request indicators");
8951
65
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8952
65
  tvb_ensure_captured_length_remaining(message_tvb, offset);
8953
65
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, INFO_REQUEST_IND_LENGTH);
8954
65
  dissect_isup_information_request_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8955
65
  offset += INFO_REQUEST_IND_LENGTH;
8956
65
  return offset;
8957
65
}
8958
8959
/* ------------------------------------------------------------------
8960
  Dissector Message Type Information
8961
 */
8962
static int
8963
dissect_isup_information_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
8964
16
{
8965
16
  proto_item *parameter_item;
8966
16
  proto_tree *parameter_tree;
8967
16
  tvbuff_t   *parameter_tvb;
8968
16
  int         offset = 0;
8969
16
  int         parameter_type;
8970
8971
  /* Do stuff for first mandatory fixed parameter: Information  indicators*/
8972
16
  parameter_type = PARAM_TYPE_INFO_IND;
8973
16
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8974
16
                                       INFO_IND_LENGTH, ett_isup_parameter, &parameter_item,
8975
16
                                       "Information indicators");
8976
16
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
8977
16
  tvb_ensure_captured_length_remaining(message_tvb, offset);
8978
16
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, INFO_IND_LENGTH);
8979
16
  dissect_isup_information_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
8980
16
  offset += INFO_IND_LENGTH;
8981
16
  return offset;
8982
16
}
8983
8984
/* ------------------------------------------------------------------
8985
  Dissector Message Type Continuity
8986
 */
8987
static int
8988
dissect_isup_continuity_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
8989
2
{ proto_item *parameter_item;
8990
2
  proto_tree *parameter_tree;
8991
2
  tvbuff_t   *parameter_tvb;
8992
2
  int         offset = 0;
8993
2
  int         parameter_type;
8994
8995
  /* Do stuff for first mandatory fixed parameter: Continuity indicators*/
8996
2
  parameter_type = PARAM_TYPE_CONTINUITY_IND;
8997
2
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
8998
2
                                       CONTINUITY_IND_LENGTH, ett_isup_parameter, &parameter_item,
8999
2
                                       "Continuity indicators");
9000
2
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9001
2
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9002
2
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, CONTINUITY_IND_LENGTH);
9003
2
  dissect_isup_continuity_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
9004
2
  offset += CONTINUITY_IND_LENGTH;
9005
2
  return offset;
9006
2
}
9007
9008
/* ------------------------------------------------------------------
9009
  Dissector Message Type Address complete
9010
 */
9011
static int
9012
dissect_isup_address_complete_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9013
28
{
9014
28
  proto_item *parameter_item;
9015
28
  proto_tree *parameter_tree;
9016
28
  tvbuff_t   *parameter_tvb;
9017
28
  int         offset = 0;
9018
28
  int         parameter_type;
9019
9020
  /* Do stuff for first mandatory fixed parameter: backward call indicators*/
9021
28
  parameter_type = PARAM_TYPE_BACKW_CALL_IND;
9022
28
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9023
28
                                       BACKWARD_CALL_IND_LENGTH, ett_isup_parameter, &parameter_item,
9024
28
                                       "Backward Call Indicators");
9025
28
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9026
28
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9027
28
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, BACKWARD_CALL_IND_LENGTH);
9028
28
  dissect_isup_backward_call_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9029
28
  offset += BACKWARD_CALL_IND_LENGTH;
9030
28
  return offset;
9031
28
}
9032
9033
static int
9034
dissect_ansi_isup_address_complete_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9035
0
{
9036
0
  proto_item *parameter_item;
9037
0
  proto_tree *parameter_tree;
9038
0
  tvbuff_t   *parameter_tvb;
9039
0
  int         offset = 0;
9040
0
  int         parameter_type;
9041
9042
  /* Do stuff for first mandatory fixed parameter: backward call indicators*/
9043
0
  parameter_type = PARAM_TYPE_BACKW_CALL_IND;
9044
0
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9045
0
    BACKWARD_CALL_IND_LENGTH, ett_isup_parameter, &parameter_item,
9046
0
    "Backward Call Indicators");
9047
0
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9048
0
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9049
0
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, BACKWARD_CALL_IND_LENGTH);
9050
0
  dissect_ansi_isup_backward_call_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9051
0
  offset += BACKWARD_CALL_IND_LENGTH;
9052
0
  return offset;
9053
0
}
9054
9055
/* ------------------------------------------------------------------
9056
  Dissector Message Type Connect
9057
 */
9058
static int
9059
dissect_isup_connect_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9060
103
{ proto_item *parameter_item;
9061
103
  proto_tree *parameter_tree;
9062
103
  tvbuff_t   *parameter_tvb;
9063
103
  int         offset = 0;
9064
103
  int         parameter_type;
9065
9066
  /* Do stuff for first mandatory fixed parameter: backward call indicators*/
9067
103
  parameter_type = PARAM_TYPE_BACKW_CALL_IND;
9068
103
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9069
103
                                       BACKWARD_CALL_IND_LENGTH, ett_isup_parameter, &parameter_item,
9070
103
                                       "Backward Call Indicators");
9071
103
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9072
103
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9073
103
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, BACKWARD_CALL_IND_LENGTH);
9074
103
  dissect_isup_backward_call_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9075
103
  offset += BACKWARD_CALL_IND_LENGTH;
9076
103
  return offset;
9077
103
}
9078
9079
/* ------------------------------------------------------------------
9080
  Dissector Message Type release message
9081
 */
9082
static int
9083
dissect_isup_release_message(tvbuff_t *message_tvb, packet_info* pinfo, proto_tree *isup_tree)
9084
14
{ proto_item *parameter_item;
9085
14
  proto_tree *parameter_tree;
9086
14
  tvbuff_t   *parameter_tvb;
9087
14
  int         offset = 0;
9088
14
  int         parameter_type, parameter_pointer, parameter_length;
9089
9090
  /* Do stuff for mandatory variable parameter Cause indicators */
9091
14
  parameter_type =  PARAM_TYPE_CAUSE_INDICATORS;
9092
9093
14
  parameter_pointer = tvb_get_uint8(message_tvb, offset);
9094
14
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9095
9096
14
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9097
14
                                       offset +  parameter_pointer,
9098
14
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9099
14
                                        ett_isup_parameter, &parameter_item,
9100
14
                                       "Cause indicators");
9101
14
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9102
14
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9103
14
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
9104
14
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9105
14
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9106
14
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9107
14
  parameter_tvb = tvb_new_subset_length(message_tvb,
9108
14
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9109
14
                                 parameter_length);
9110
14
  switch (isup_standard) {
9111
14
    case ITU_STANDARD:
9112
14
      dissect_isup_cause_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9113
14
      break;
9114
0
    case ANSI_STANDARD:
9115
0
      dissect_ansi_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
9116
0
      break;
9117
14
  }
9118
13
  offset += PARAMETER_POINTER_LENGTH;
9119
9120
13
  return offset;
9121
14
}
9122
9123
/* ------------------------------------------------------------------
9124
  Dissector Message Type Resume/Suspend
9125
 */
9126
static int
9127
dissect_isup_suspend_resume_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9128
53
{ proto_item *parameter_item;
9129
53
  proto_tree *parameter_tree;
9130
53
  tvbuff_t   *parameter_tvb;
9131
53
  int         offset = 0;
9132
53
  int         parameter_type;
9133
9134
  /* Do stuff for first mandatory fixed parameter: backward call indicators*/
9135
53
  parameter_type = PARAM_TYPE_SUSP_RESUME_IND;
9136
53
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9137
53
                                       SUSPEND_RESUME_IND_LENGTH,
9138
53
                                        ett_isup_parameter, &parameter_item,
9139
53
                                       "Suspend/Resume indicator");
9140
53
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9141
53
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9142
53
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, SUSPEND_RESUME_IND_LENGTH);
9143
53
  dissect_isup_suspend_resume_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
9144
53
  offset += SUSPEND_RESUME_IND_LENGTH;
9145
53
  return offset;
9146
53
}
9147
9148
/* ------------------------------------------------------------------
9149
  Dissector Message Type Circuit group reset/query message
9150
 */
9151
static int
9152
dissect_isup_circuit_group_reset_query_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9153
5
{ proto_item *parameter_item;
9154
5
  proto_tree *parameter_tree;
9155
5
  tvbuff_t   *parameter_tvb;
9156
5
  int         offset = 0;
9157
5
  int         parameter_type, parameter_pointer, parameter_length;
9158
9159
  /* Do stuff for mandatory variable parameter range and status*/
9160
5
  parameter_type =  PARAM_TYPE_RANGE_AND_STATUS;
9161
9162
5
  parameter_pointer = tvb_get_uint8(message_tvb, offset);
9163
5
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9164
9165
5
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9166
5
                                       offset +  parameter_pointer,
9167
5
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9168
5
                                        ett_isup_parameter, &parameter_item,
9169
5
                                       "Range and status");
9170
5
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9171
5
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9172
5
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
9173
5
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9174
5
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9175
5
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9176
5
  parameter_tvb = tvb_new_subset_length(message_tvb,
9177
5
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9178
5
                                 parameter_length);
9179
5
  dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9180
5
  offset += PARAMETER_POINTER_LENGTH;
9181
9182
5
  return offset;
9183
5
}
9184
9185
/* ------------------------------------------------------------------
9186
  Dissector Message Type Circuit group blocking/blocking ack/unblocking/unblocking ack messages
9187
 */
9188
static int
9189
dissect_isup_circuit_group_blocking_messages(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9190
8
{ proto_item *parameter_item;
9191
8
  proto_tree *parameter_tree;
9192
8
  tvbuff_t   *parameter_tvb;
9193
8
  int         offset = 0;
9194
8
  int         parameter_type, parameter_pointer, parameter_length;
9195
9196
   /* Do stuff for first mandatory fixed parameter: circuit group supervision message type*/
9197
8
  parameter_type = PARAM_TYPE_CIRC_GRP_SV_MSG_TYPE;
9198
8
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9199
8
                                       CIRC_GRP_SV_MSG_TYPE_LENGTH,
9200
8
                                        ett_isup_parameter, &parameter_item,
9201
8
                                       "Circuit group supervision message type");
9202
8
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9203
8
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9204
8
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, CIRC_GRP_SV_MSG_TYPE_LENGTH);
9205
8
  dissect_isup_circuit_group_supervision_message_type_parameter(parameter_tvb, parameter_tree, parameter_item);
9206
8
  offset += CIRC_GRP_SV_MSG_TYPE_LENGTH;
9207
9208
  /* Do stuff for mandatory variable parameter range and status*/
9209
8
  parameter_type =  PARAM_TYPE_RANGE_AND_STATUS;
9210
9211
8
  parameter_pointer = tvb_get_uint8(message_tvb, offset);
9212
8
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9213
9214
8
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9215
8
                                       offset +  parameter_pointer,
9216
8
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9217
8
                                        ett_isup_parameter, &parameter_item,
9218
8
                                       "Range and status");
9219
8
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9220
8
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9221
8
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
9222
8
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9223
8
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9224
8
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9225
8
  parameter_tvb = tvb_new_subset_length(message_tvb,
9226
8
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9227
8
                                 parameter_length);
9228
8
  dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9229
8
  offset += PARAMETER_POINTER_LENGTH;
9230
9231
8
  return offset;
9232
8
}
9233
9234
/* ------------------------------------------------------------------
9235
  Dissector Message Type Facility request/accepted
9236
 */
9237
static int
9238
dissect_isup_facility_request_accepted_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9239
25
{ proto_item *parameter_item;
9240
25
  proto_tree *parameter_tree;
9241
25
  tvbuff_t   *parameter_tvb;
9242
25
  int         offset = 0;
9243
25
  int         parameter_type;
9244
9245
  /* Do stuff for first mandatory fixed parameter: facility indicators*/
9246
25
  parameter_type = PARAM_TYPE_FACILITY_IND;
9247
25
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9248
25
                                       FACILITY_IND_LENGTH,
9249
25
                                        ett_isup_parameter, &parameter_item,
9250
25
                                       "Facility indicator");
9251
25
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9252
25
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9253
25
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, FACILITY_IND_LENGTH);
9254
25
  dissect_isup_facility_ind_parameter(parameter_tvb, parameter_item);
9255
25
  offset += FACILITY_IND_LENGTH;
9256
25
  return offset;
9257
25
}
9258
9259
/* ------------------------------------------------------------------
9260
  Dissector Message Type Facility reject
9261
 */
9262
static int
9263
dissect_isup_facility_reject_message(tvbuff_t *message_tvb, packet_info* pinfo, proto_tree *isup_tree)
9264
18
{ proto_item *parameter_item;
9265
18
  proto_tree *parameter_tree;
9266
18
  tvbuff_t   *parameter_tvb;
9267
18
  int         offset = 0;
9268
18
  int         parameter_type, parameter_pointer, parameter_length;
9269
9270
  /* Do stuff for first mandatory fixed parameter: facility indicators*/
9271
18
  parameter_type = PARAM_TYPE_FACILITY_IND;
9272
18
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9273
18
                                       FACILITY_IND_LENGTH,
9274
18
                                        ett_isup_parameter, &parameter_item,
9275
18
                                       "Facility indicator");
9276
18
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9277
18
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9278
18
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, FACILITY_IND_LENGTH);
9279
18
  dissect_isup_facility_ind_parameter(parameter_tvb, parameter_item);
9280
18
  offset += FACILITY_IND_LENGTH;
9281
9282
  /* Do stuff for mandatory variable parameter Cause indicators */
9283
18
  parameter_type =  PARAM_TYPE_CAUSE_INDICATORS;
9284
9285
18
  parameter_pointer = tvb_get_uint8(message_tvb, offset);
9286
18
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9287
9288
18
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9289
18
                                       offset +  parameter_pointer,
9290
18
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9291
18
                                        ett_isup_parameter, &parameter_item,
9292
18
                                       "Cause indicators, see Q.850");
9293
18
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9294
18
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb,
9295
18
                             offset, PARAMETER_POINTER_LENGTH, parameter_pointer);
9296
18
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9297
18
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9298
18
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9299
18
  parameter_tvb = tvb_new_subset_length(message_tvb,
9300
18
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9301
18
                                 parameter_length);
9302
18
  switch (isup_standard) {
9303
18
    case ITU_STANDARD:
9304
18
      dissect_isup_cause_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9305
18
      break;
9306
0
    case ANSI_STANDARD:
9307
0
      dissect_ansi_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
9308
0
      break;
9309
18
  }
9310
17
  offset += PARAMETER_POINTER_LENGTH;
9311
9312
17
  return offset;
9313
18
}
9314
9315
/* ------------------------------------------------------------------
9316
  Dissector Message Type Circuit group reset acknowledgement message
9317
 */
9318
static int
9319
dissect_isup_circuit_group_reset_acknowledgement_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9320
2
{ proto_item *parameter_item;
9321
2
  proto_tree *parameter_tree;
9322
2
  tvbuff_t   *parameter_tvb;
9323
2
  int         offset = 0;
9324
2
  int         parameter_type, parameter_pointer, parameter_length;
9325
9326
  /* Do stuff for mandatory variable parameter range and status*/
9327
2
  parameter_type =  PARAM_TYPE_RANGE_AND_STATUS;
9328
9329
2
  parameter_pointer = tvb_get_uint8(message_tvb, offset);
9330
2
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9331
9332
2
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9333
2
                                       offset +  parameter_pointer,
9334
2
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9335
2
                                       ett_isup_parameter, &parameter_item,
9336
2
                                       "Range and status");
9337
2
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9338
2
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9339
2
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
9340
2
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9341
2
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9342
2
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9343
2
  parameter_tvb = tvb_new_subset_length(message_tvb,
9344
2
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9345
2
                                 parameter_length);
9346
2
  dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9347
2
  offset += PARAMETER_POINTER_LENGTH;
9348
9349
2
  return offset;
9350
2
}
9351
9352
/* ------------------------------------------------------------------
9353
  Dissector Message Type Circuit group query response message
9354
 */
9355
static int
9356
dissect_isup_circuit_group_query_response_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9357
8
{ proto_item *parameter_item;
9358
8
  proto_tree *parameter_tree;
9359
8
  tvbuff_t   *parameter_tvb;
9360
8
  int         offset = 0;
9361
8
  int         parameter_type, parameter_pointer, parameter_length;
9362
9363
  /* Do stuff for 1. mandatory variable parameter range and status*/
9364
8
  parameter_type =  PARAM_TYPE_RANGE_AND_STATUS;
9365
9366
8
  parameter_pointer = tvb_get_uint8(message_tvb, offset);
9367
8
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9368
9369
8
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9370
8
                                       offset +  parameter_pointer,
9371
8
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9372
8
                                        ett_isup_parameter, &parameter_item,
9373
8
                                       "Range and status");
9374
8
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9375
8
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9376
8
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
9377
8
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9378
8
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9379
8
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9380
8
  parameter_tvb = tvb_new_subset_length(message_tvb,
9381
8
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9382
8
                                 parameter_length);
9383
8
  dissect_isup_range_and_status_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9384
8
  offset += PARAMETER_POINTER_LENGTH;
9385
9386
  /* Do stuff for 2. mandatory variable parameter Circuit state indicator*/
9387
8
  parameter_type = PARAM_TYPE_CIRC_STATE_IND;
9388
9389
8
  parameter_pointer = tvb_get_uint8(message_tvb, offset);
9390
8
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9391
9392
8
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9393
8
                                       offset +  parameter_pointer,
9394
8
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9395
8
                                        ett_isup_parameter, &parameter_item,
9396
8
                                       "Circuit state indicator (national use)");
9397
8
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9398
8
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9399
8
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
9400
8
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9401
8
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9402
8
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9403
8
  parameter_tvb = tvb_new_subset_length(message_tvb,
9404
8
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9405
8
                                 parameter_length);
9406
8
  dissect_isup_circuit_state_ind_parameter(parameter_tvb, parameter_tree, parameter_item);
9407
8
  offset += PARAMETER_POINTER_LENGTH;
9408
9409
8
  return offset;
9410
8
}
9411
9412
/* ------------------------------------------------------------------
9413
  Dissector Message Type Call Progress
9414
*/
9415
static int
9416
dissect_isup_call_progress_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9417
3
{ proto_item *parameter_item;
9418
3
  proto_tree *parameter_tree;
9419
3
  tvbuff_t   *parameter_tvb;
9420
3
  int         offset = 0;
9421
3
  int         parameter_type;
9422
9423
  /* Do stuff for first mandatory fixed parameter: Event information*/
9424
3
  parameter_type = PARAM_TYPE_EVENT_INFO;
9425
3
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset,
9426
3
                                       EVENT_INFO_LENGTH, ett_isup_parameter, &parameter_item,
9427
3
                                       "Event information");
9428
3
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9429
3
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9430
3
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, EVENT_INFO_LENGTH);
9431
3
  dissect_isup_event_information_parameter(parameter_tvb, parameter_tree, parameter_item);
9432
3
  offset += EVENT_INFO_LENGTH;
9433
3
  return offset;
9434
3
}
9435
9436
/* ------------------------------------------------------------------
9437
  Dissector Message Type User-to-User information
9438
 */
9439
static int
9440
dissect_isup_user_to_user_information_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9441
17
{ proto_item *parameter_item;
9442
17
  proto_tree *parameter_tree;
9443
17
  tvbuff_t   *parameter_tvb;
9444
17
  int         offset = 0;
9445
17
  int         parameter_type, parameter_pointer, parameter_length;
9446
9447
  /* Do stuff for mandatory variable parameter User-to-user information*/
9448
17
  parameter_type =  PARAM_TYPE_USER_TO_USER_INFO;
9449
9450
17
  parameter_pointer = tvb_get_uint8(message_tvb, offset);
9451
17
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9452
9453
17
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9454
17
                                       offset +  parameter_pointer,
9455
17
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9456
17
                                       ett_isup_parameter, &parameter_item,
9457
17
                                       "User-to-user information, see Q.931");
9458
17
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9459
17
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9460
17
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
9461
17
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9462
17
                             PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9463
17
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9464
17
  parameter_tvb = tvb_new_subset_length(message_tvb,
9465
17
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9466
17
                                 parameter_length);
9467
17
  dissect_isup_user_to_user_information_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9468
17
  offset += PARAMETER_POINTER_LENGTH;
9469
9470
17
  return offset;
9471
17
}
9472
9473
/* ------------------------------------------------------------------
9474
  Dissector Message Type Confusion
9475
 */
9476
static int
9477
dissect_isup_confusion_message(tvbuff_t *message_tvb, packet_info* pinfo, proto_tree *isup_tree)
9478
4
{ proto_item *parameter_item;
9479
4
  proto_tree *parameter_tree;
9480
4
  tvbuff_t   *parameter_tvb;
9481
4
  int         offset = 0;
9482
4
  int         parameter_type, parameter_pointer, parameter_length;
9483
9484
  /* Do stuff for mandatory variable parameter Cause indicators */
9485
4
  parameter_type =  PARAM_TYPE_CAUSE_INDICATORS;
9486
9487
4
  parameter_pointer = tvb_get_uint8(message_tvb, offset);
9488
4
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9489
9490
4
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9491
4
                                       offset +  parameter_pointer,
9492
4
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9493
4
                                        ett_isup_parameter, &parameter_item,
9494
4
                                       "Cause indicators, see Q.850");
9495
4
  proto_tree_add_uint(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type);
9496
4
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9497
4
                             PARAMETER_POINTER_LENGTH, parameter_pointer);
9498
4
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length,
9499
4
                             message_tvb, offset + parameter_pointer, PARAMETER_LENGTH_IND_LENGTH,
9500
4
                             parameter_length);
9501
4
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9502
4
  parameter_tvb = tvb_new_subset_length(message_tvb,
9503
4
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9504
4
                                 parameter_length);
9505
9506
4
  switch (isup_standard) {
9507
4
    case ITU_STANDARD:
9508
4
      dissect_isup_cause_indicators_parameter(parameter_tvb, pinfo, parameter_tree, parameter_item);
9509
4
      break;
9510
0
    case ANSI_STANDARD:
9511
0
      dissect_ansi_isup_cause_indicators_parameter(parameter_tvb, parameter_tree, parameter_item);
9512
0
      break;
9513
4
  }
9514
3
  offset += PARAMETER_POINTER_LENGTH;
9515
9516
3
  return offset;
9517
4
}
9518
9519
/* Dissect national messages */
9520
static int
9521
dissect_french_isup_charging_pulse_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9522
0
{
9523
0
  unsigned offset = 0;
9524
9525
0
  proto_tree_add_item(isup_tree, hf_isup_french_coll_field, message_tvb, offset, 1, ENC_BIG_ENDIAN);
9526
0
  offset += 1;
9527
0
  proto_tree_add_item(isup_tree, hf_isup_french_msg_num, message_tvb, offset, 1, ENC_BIG_ENDIAN);
9528
0
  offset += 1;
9529
9530
0
  return offset;
9531
0
}
9532
9533
static const value_string israeli_cmi_current_rate[] = {
9534
  { 0,   "Current rate not present" },
9535
  { 1,   "Rate expressed in deciseconds" },
9536
  { 2,   "Rate expressed in centiseconds" },
9537
  { 3,   "Rate expressed in milliseconds" },
9538
  { 0,   NULL}
9539
};
9540
static const value_string israeli_cmi_next_rate[] = {
9541
  { 0,   "Time indicator and next rate not present" },
9542
  { 1,   "Rate expressed in deciseconds" },
9543
  { 2,   "Rate expressed in centiseconds" },
9544
  { 3,   "Rate expressed in milliseconds" },
9545
  { 0,   NULL}
9546
};
9547
static const value_string israeli_time_indicators[] = {
9548
  {  0,   "spare" },
9549
  {  1,   "00.30 H" },
9550
  {  2,   "01.00 H" },
9551
  {  3,   "01.30 H" },
9552
  {  4,   "02.00 H" },
9553
  {  5,   "02.30 H" },
9554
  {  6,   "03.00 H" },
9555
  {  7,   "03.30 H" },
9556
  {  8,   "04.00 H" },
9557
  {  9,   "04.30 H" },
9558
  { 10,   "05.00 H" },
9559
  { 11,   "05.30 H" },
9560
  { 12,   "06.00 H" },
9561
  { 13,   "06.30 H" },
9562
  { 14,   "07.00 H" },
9563
  { 15,   "07.30 H" },
9564
  { 16,   "08.00 H" },
9565
  { 17,   "08.30 H" },
9566
  { 18,   "09.00 H" },
9567
  { 19,   "09.30 H" },
9568
  { 20,   "10.00 H" },
9569
  { 21,   "10.30 H" },
9570
  { 22,   "11.00 H" },
9571
  { 23,   "11.30 H" },
9572
  { 24,   "12.00 H" },
9573
  { 25,   "12.30 H" },
9574
  { 26,   "13.00 H" },
9575
  { 27,   "13.30 H" },
9576
  { 28,   "14.00 H" },
9577
  { 29,   "14.30 H" },
9578
  { 30,   "15.00 H" },
9579
  { 31,   "15.30 H" },
9580
  { 32,   "16.00 H" },
9581
  { 33,   "16.30 H" },
9582
  { 34,   "17.00 H" },
9583
  { 35,   "17.30 H" },
9584
  { 36,   "18.00 H" },
9585
  { 37,   "18.30 H" },
9586
  { 38,   "19.00 H" },
9587
  { 39,   "19.30 H" },
9588
  { 40,   "20.00 H" },
9589
  { 41,   "20.30 H" },
9590
  { 42,   "21.00 H" },
9591
  { 43,   "21.30 H" },
9592
  { 44,   "22.00 H" },
9593
  { 45,   "22.30 H" },
9594
  { 46,   "23.00 H" },
9595
  { 47,   "23.30 H" },
9596
  { 48,   "24.00 H" },
9597
  { 0,   NULL}
9598
};
9599
static value_string_ext israeli_time_indicators_ext = VALUE_STRING_EXT_INIT(israeli_time_indicators);
9600
9601
static int
9602
dissect_israeli_backward_charging_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9603
0
{
9604
0
  unsigned offset = 0;
9605
9606
0
  proto_tree_add_item(isup_tree, hf_isup_israeli_charging_message_indicators_current, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
9607
0
  proto_tree_add_item(isup_tree, hf_isup_israeli_charging_message_indicators_next, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
9608
0
  offset += 1;
9609
0
  proto_tree_add_item(isup_tree, hf_isup_israeli_current_rate, message_tvb, offset, 2, ENC_LITTLE_ENDIAN);
9610
0
  offset += 2;
9611
0
  proto_tree_add_item(isup_tree, hf_isup_israeli_time_indicator, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
9612
0
  offset += 1;
9613
0
  proto_tree_add_item(isup_tree, hf_isup_israeli_next_rate, message_tvb, offset, 2, ENC_LITTLE_ENDIAN);
9614
0
  offset += 2;
9615
9616
0
  return offset;
9617
0
}
9618
9619
static int
9620
dissect_israeli_traffic_change_message(tvbuff_t *message_tvb, proto_tree *isup_tree)
9621
0
{
9622
0
  unsigned offset = 0;
9623
9624
0
  proto_tree_add_item(isup_tree, hf_isup_israeli_charging_message_indicators_current, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
9625
0
  proto_tree_add_item(isup_tree, hf_isup_israeli_charging_message_indicators_next, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
9626
0
  offset += 1;
9627
0
  proto_tree_add_item(isup_tree, hf_isup_israeli_time_indicator, message_tvb, offset, 1, ENC_LITTLE_ENDIAN);
9628
0
  offset += 1;
9629
0
  proto_tree_add_item(isup_tree, hf_isup_israeli_next_rate, message_tvb, offset, 2, ENC_LITTLE_ENDIAN);
9630
0
  offset += 2;
9631
9632
0
  return offset;
9633
0
}
9634
9635
static int
9636
dissect_japan_chg_inf(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree)
9637
0
{
9638
0
  proto_item *parameter_item;
9639
0
  proto_tree *parameter_tree;
9640
0
  tvbuff_t   *parameter_tvb;
9641
0
  int         offset = 0;
9642
0
  int         parameter_type, parameter_pointer, parameter_length;
9643
0
  uint8_t     chg_inf_type;
9644
9645
  /* Do stuff for first mandatory fixed parameter: Charge information type */
9646
0
  parameter_type = JAPAN_ISUP_PARAM_TYPE_CHARGE_INF_TYPE;
9647
0
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb, offset, 1,
9648
0
                            ett_isup_parameter, &parameter_item, "Charge information type");
9649
0
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type,
9650
0
                             "%u (%s)",
9651
0
                             parameter_type,
9652
0
                             val_to_str_ext_const(parameter_type, &japan_isup_parameter_type_value_ext, "unknown"));
9653
0
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9654
0
  parameter_tvb = tvb_new_subset_length(message_tvb, offset, 1);
9655
0
  chg_inf_type = tvb_get_uint8(parameter_tvb, 0);
9656
0
  dissect_japan_chg_inf_type(parameter_tvb, parameter_tree, parameter_item);
9657
0
  offset += 1;
9658
9659
  /* Do stuff for mandatory variable parameter Charge information */
9660
0
  parameter_type = JAPAN_ISUP_PARAM_TYPE_CHARGE_INF;
9661
0
  parameter_pointer = tvb_get_uint8(message_tvb, offset);
9662
0
  parameter_length  = tvb_get_uint8(message_tvb, offset + parameter_pointer);
9663
9664
0
  parameter_tree = proto_tree_add_subtree(isup_tree, message_tvb,
9665
0
                                       offset +  parameter_pointer,
9666
0
                                       parameter_length + PARAMETER_LENGTH_IND_LENGTH,
9667
0
                                       ett_isup_parameter, &parameter_item,
9668
0
                                       "Charge information");
9669
0
  proto_tree_add_uint_format_value(parameter_tree, hf_isup_mand_parameter_type, message_tvb, 0, 0, parameter_type,
9670
0
                             "%u (%s)",
9671
0
                             parameter_type,
9672
0
                             val_to_str_ext_const(parameter_type, &japan_isup_parameter_type_value_ext, "unknown"));
9673
0
  proto_tree_add_uint(parameter_tree, hf_isup_mandatory_variable_parameter_pointer, message_tvb, offset,
9674
0
                      PARAMETER_POINTER_LENGTH, parameter_pointer);
9675
0
  proto_tree_add_uint(parameter_tree, hf_isup_parameter_length, message_tvb, offset + parameter_pointer,
9676
0
                      PARAMETER_LENGTH_IND_LENGTH, parameter_length);
9677
0
  tvb_ensure_captured_length_remaining(message_tvb, offset);
9678
0
  parameter_tvb = tvb_new_subset_length(message_tvb,
9679
0
                                 offset + parameter_pointer + PARAMETER_LENGTH_IND_LENGTH,
9680
0
                                 parameter_length);
9681
9682
  /* TODO: Dissect the parameter here, switch on type */
9683
0
  switch (chg_inf_type) {
9684
0
    case 3:
9685
      /* Advanced Charge Rate Transfer (TDS service) */
9686
0
      dissect_japan_chg_inf_type_acr(parameter_tvb, parameter_tree, parameter_item);
9687
0
      break;
9688
0
    case 254:
9689
      /* Charge rate transfer (flexible charging) */
9690
0
      dissect_japan_chg_inf_type_crt(parameter_tvb, parameter_tree, parameter_item);
9691
0
      break;
9692
0
    default:
9693
0
      proto_tree_add_expert_format_remaining(parameter_tree, pinfo, &ei_isup_not_dissected_yet, parameter_tvb, 0, "Charge information data, not dissected yet");
9694
0
      break;
9695
0
  }
9696
9697
9698
0
  offset += PARAMETER_POINTER_LENGTH;
9699
9700
0
  return offset;
9701
9702
0
}
9703
9704
/* ------------------------------------------------------------------ */
9705
// NOLINTBEGIN(misc-no-recursion)
9706
static void
9707
dissect_ansi_isup_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree, uint8_t itu_isup_variant, uint32_t circuit_id)
9708
0
{
9709
0
  isup_tap_rec_t *tap_rec;
9710
9711
0
  tvbuff_t   *parameter_tvb;
9712
0
  tvbuff_t   *optional_parameter_tvb;
9713
0
  proto_tree *pass_along_tree;
9714
0
  proto_item *type_item;
9715
0
  int         offset, bufferlength;
9716
0
  uint32_t    message_type;
9717
0
  uint8_t     opt_parameter_pointer;
9718
0
  bool        opt_part_possible = false; /* default setting - for message types allowing optional
9719
                                            params explicitly set to true in case statement */
9720
0
  tap_calling_number            = NULL;
9721
0
  offset                        = 0;
9722
9723
  // We call ourselves for MESSAGE_TYPE_PASS_ALONG.
9724
0
  increment_dissection_depth(pinfo);
9725
9726
  /* Extract message type field */
9727
0
  type_item = proto_tree_add_item_ret_uint(isup_tree, hf_isup_message_type_ansi, message_tvb, 0, MESSAGE_TYPE_LENGTH, ENC_NA, &message_type);
9728
9729
0
  offset +=  MESSAGE_TYPE_LENGTH;
9730
9731
0
  tap_rec = wmem_new(pinfo->pool, isup_tap_rec_t);
9732
0
  tap_rec->message_type   = message_type;
9733
0
  tap_rec->itu_isup_variant = itu_isup_variant;
9734
0
  tap_rec->calling_number = NULL;
9735
0
  tap_rec->called_number  = NULL;
9736
0
  tap_rec->circuit_id     = circuit_id;
9737
9738
0
  parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);
9739
9740
  /* distinguish between message types:*/
9741
0
  switch (message_type) {
9742
0
    case MESSAGE_TYPE_INITIAL_ADDR:
9743
0
      offset += dissect_isup_initial_address_message(parameter_tvb, pinfo, isup_tree, itu_isup_variant);
9744
0
      opt_part_possible = true;
9745
0
      break;
9746
0
    case MESSAGE_TYPE_SUBSEQ_ADDR:
9747
0
      offset += dissect_isup_subsequent_address_message(parameter_tvb, pinfo, isup_tree);
9748
0
      opt_part_possible = true;
9749
0
      break;
9750
0
    case MESSAGE_TYPE_INFO_REQ:
9751
0
      offset += dissect_isup_information_request_message(parameter_tvb, isup_tree);
9752
0
      opt_part_possible = true;
9753
0
      break;
9754
0
    case MESSAGE_TYPE_INFO:
9755
0
      offset += dissect_isup_information_message(parameter_tvb, isup_tree);
9756
0
      opt_part_possible = true;
9757
0
      break;
9758
0
    case MESSAGE_TYPE_CONTINUITY:
9759
0
      offset += dissect_isup_continuity_message(parameter_tvb, isup_tree);
9760
0
      break;
9761
0
    case MESSAGE_TYPE_ADDR_CMPL:
9762
0
      offset += dissect_ansi_isup_address_complete_message(parameter_tvb, pinfo, isup_tree);
9763
0
      opt_part_possible = true;
9764
0
      break;
9765
0
    case MESSAGE_TYPE_CONNECT:
9766
0
      offset += dissect_isup_connect_message(parameter_tvb, pinfo, isup_tree);
9767
0
      opt_part_possible = true;
9768
0
      break;
9769
0
    case MESSAGE_TYPE_FORW_TRANS:
9770
      /* no dissector necessary since no mandatory parameters included */
9771
0
      opt_part_possible = true;
9772
0
      break;
9773
0
    case MESSAGE_TYPE_ANSWER:
9774
      /* no dissector necessary since no mandatory parameters included */
9775
0
      opt_part_possible = true;
9776
0
      break;
9777
0
    case MESSAGE_TYPE_RELEASE:
9778
0
      offset += dissect_isup_release_message(parameter_tvb, pinfo, isup_tree);
9779
0
      opt_part_possible = true;
9780
0
      break;
9781
0
    case MESSAGE_TYPE_SUSPEND:
9782
0
      offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
9783
0
      opt_part_possible = true;
9784
0
      break;
9785
0
    case MESSAGE_TYPE_RESUME:
9786
0
      offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
9787
0
      opt_part_possible = true;
9788
0
      break;
9789
0
    case MESSAGE_TYPE_REL_CMPL:
9790
      /* no dissector necessary since no mandatory parameters included */
9791
0
      break;
9792
0
    case MESSAGE_TYPE_CONT_CHECK_REQ:
9793
      /* no dissector necessary since no mandatory parameters included */
9794
0
      break;
9795
0
    case MESSAGE_TYPE_RESET_CIRCUIT:
9796
      /* no dissector necessary since no mandatory parameters included */
9797
0
      break;
9798
0
    case MESSAGE_TYPE_BLOCKING:
9799
      /* no dissector necessary since no mandatory parameters included */
9800
0
      break;
9801
0
    case MESSAGE_TYPE_UNBLOCKING:
9802
      /* no dissector necessary since no mandatory parameters included */
9803
0
      break;
9804
0
    case MESSAGE_TYPE_BLOCK_ACK:
9805
      /* no dissector necessary since no mandatory parameters included */
9806
0
      break;
9807
0
    case MESSAGE_TYPE_UNBLOCK_ACK:
9808
      /* no dissector necessary since no mandatory parameters included */
9809
0
      break;
9810
0
    case MESSAGE_TYPE_CIRC_GRP_RST:
9811
0
      offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, pinfo, isup_tree);
9812
0
      break;
9813
0
    case MESSAGE_TYPE_CIRC_GRP_BLCK:
9814
0
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
9815
0
      break;
9816
0
    case MESSAGE_TYPE_CIRC_GRP_UNBL:
9817
0
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
9818
0
      break;
9819
0
    case MESSAGE_TYPE_CIRC_GRP_BL_ACK:
9820
0
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
9821
0
      break;
9822
0
    case MESSAGE_TYPE_CIRC_GRP_UNBL_ACK:
9823
0
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
9824
0
      break;
9825
0
    case MESSAGE_TYPE_FACILITY_REQ:
9826
0
      offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
9827
0
      opt_part_possible = true;
9828
0
      break;
9829
0
    case MESSAGE_TYPE_FACILITY_ACC:
9830
0
      offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
9831
0
      opt_part_possible = true;
9832
0
      break;
9833
0
    case MESSAGE_TYPE_FACILITY_REJ:
9834
0
      offset += dissect_isup_facility_reject_message(parameter_tvb, pinfo, isup_tree);
9835
0
      opt_part_possible = true;
9836
0
      break;
9837
0
    case MESSAGE_TYPE_LOOP_BACK_ACK:
9838
      /* no dissector necessary since no mandatory parameters included */
9839
0
      break;
9840
0
    case MESSAGE_TYPE_PASS_ALONG:
9841
      /* call dissect_isup_message recursively */
9842
0
    {
9843
0
      uint8_t pa_message_type;
9844
0
      pa_message_type = tvb_get_uint8(parameter_tvb, 0);
9845
0
      pass_along_tree = proto_tree_add_subtree_format(isup_tree, parameter_tvb, offset, -1,
9846
0
                                            ett_isup_pass_along_message, NULL, "Pass-along: %s Message (%u)",
9847
0
                                            val_to_str_ext_const(pa_message_type, &isup_message_type_value_acro_ext, "reserved"),
9848
0
                                            pa_message_type);
9849
0
      dissect_ansi_isup_message(parameter_tvb, pinfo, pass_along_tree, itu_isup_variant, circuit_id);
9850
0
      break;
9851
0
    }
9852
0
    case MESSAGE_TYPE_CIRC_GRP_RST_ACK:
9853
0
      offset += dissect_isup_circuit_group_reset_acknowledgement_message(parameter_tvb, pinfo, isup_tree);
9854
0
      break;
9855
0
    case MESSAGE_TYPE_CIRC_GRP_QRY:
9856
0
      offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, pinfo, isup_tree);
9857
0
      break;
9858
0
    case MESSAGE_TYPE_CIRC_GRP_QRY_RSP:
9859
0
      offset += dissect_isup_circuit_group_query_response_message(parameter_tvb, pinfo, isup_tree);
9860
0
      break;
9861
0
    case MESSAGE_TYPE_CALL_PROGRSS:
9862
0
      offset += dissect_isup_call_progress_message(parameter_tvb, isup_tree);
9863
0
      opt_part_possible = true;
9864
0
      break;
9865
0
    case MESSAGE_TYPE_USER2USER_INFO:
9866
0
      offset += dissect_isup_user_to_user_information_message(parameter_tvb, pinfo, isup_tree);
9867
0
      opt_part_possible = true;
9868
0
      break;
9869
0
    case MESSAGE_TYPE_UNEQUIPPED_CIC:
9870
      /* no dissector necessary since no mandatory parameters included */
9871
0
      break;
9872
0
    case MESSAGE_TYPE_CONFUSION:
9873
0
      offset += dissect_isup_confusion_message(parameter_tvb, pinfo, isup_tree);
9874
0
      opt_part_possible = true;
9875
0
      break;
9876
0
    case MESSAGE_TYPE_OVERLOAD:
9877
      /* no dissector necessary since no mandatory parameters included */
9878
0
      break;
9879
0
    case MESSAGE_TYPE_CHARGE_INFO:
9880
      /* do nothing since format is a national matter */
9881
0
      bufferlength = tvb_reported_length_remaining(message_tvb, offset);
9882
0
      if (bufferlength != 0)
9883
0
        proto_tree_add_expert(isup_tree, pinfo, &ei_isup_format_national_matter, parameter_tvb, 0, bufferlength);
9884
0
      break;
9885
0
    case MESSAGE_TYPE_NETW_RESRC_MGMT:
9886
      /* no dissector necessary since no mandatory parameters included */
9887
0
      opt_part_possible = true;
9888
0
      break;
9889
0
    case MESSAGE_TYPE_FACILITY:
9890
      /* no dissector necessary since no mandatory parameters included */
9891
0
      opt_part_possible = true;
9892
0
      break;
9893
0
    case MESSAGE_TYPE_USER_PART_TEST:
9894
      /* no dissector necessary since no mandatory parameters included */
9895
0
      opt_part_possible = true;
9896
0
      break;
9897
0
    case MESSAGE_TYPE_USER_PART_AVAIL:
9898
      /* no dissector necessary since no mandatory parameters included */
9899
0
      opt_part_possible = true;
9900
0
      break;
9901
0
    case MESSAGE_TYPE_IDENT_REQ:
9902
      /* no dissector necessary since no mandatory parameters included */
9903
0
      opt_part_possible = true;
9904
0
      break;
9905
0
    case MESSAGE_TYPE_IDENT_RSP:
9906
      /* no dissector necessary since no mandatory parameters included */
9907
0
      opt_part_possible = true;
9908
0
      break;
9909
0
    case MESSAGE_TYPE_SEGMENTATION:
9910
      /* no dissector necessary since no mandatory parameters included */
9911
0
      opt_part_possible = true;
9912
0
      break;
9913
0
    case MESSAGE_TYPE_LOOP_PREVENTION:
9914
      /* no dissector necessary since no mandatory parameters included */
9915
0
      opt_part_possible = true;
9916
0
      break;
9917
0
    case MESSAGE_TYPE_APPLICATION_TRANS:
9918
      /* no dissector necessary since no mandatory parameters included */
9919
0
      opt_part_possible = true;
9920
0
      break;
9921
0
    case MESSAGE_TYPE_PRE_RELEASE_INFO:
9922
      /* no dissector necessary since no mandatory parameters included */
9923
0
      opt_part_possible = true;
9924
0
      break;
9925
0
    case MESSAGE_TYPE_SUBSEQUENT_DIR_NUM:
9926
      /* do nothing since format is a national matter */
9927
0
      bufferlength = tvb_reported_length_remaining(message_tvb, offset);
9928
0
      if (bufferlength != 0)
9929
0
        proto_tree_add_expert(isup_tree, pinfo, &ei_isup_format_national_matter, parameter_tvb, 0, bufferlength);
9930
0
      break;
9931
0
    case ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES_ACK:
9932
      /* no dissector necessary since no mandatory parameters included */
9933
0
      break;
9934
0
    case ANSI_ISUP_MESSAGE_TYPE_CIRCUIT_RES:
9935
0
      offset += dissect_ansi_isup_circuit_reservation_message(parameter_tvb, pinfo, isup_tree);
9936
0
      break;
9937
0
    case ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST_RSP:
9938
0
      opt_part_possible = true;
9939
0
      offset += dissect_ansi_isup_circuit_validation_test_resp_message(parameter_tvb, isup_tree);
9940
0
      break;
9941
0
    case ANSI_ISUP_MESSAGE_TYPE_CCT_VAL_TEST:
9942
      /* no dissector necessary since no mandatory parameters included */
9943
0
      break;
9944
0
    default:
9945
0
      bufferlength = tvb_reported_length_remaining(message_tvb, offset);
9946
0
      if (bufferlength != 0)
9947
0
        expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
9948
0
      break;
9949
0
  }
9950
9951
  /* extract pointer to start of optional part (if any) */
9952
0
  if (opt_part_possible == true) {
9953
0
    opt_parameter_pointer = tvb_get_uint8(message_tvb, offset);
9954
0
    if (opt_parameter_pointer > 0) {
9955
0
      proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
9956
0
                                 PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
9957
0
                                 "Pointer to start of optional part: %u", opt_parameter_pointer);
9958
0
      offset += opt_parameter_pointer;
9959
0
      optional_parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);
9960
0
      dissect_ansi_isup_optional_parameter(optional_parameter_tvb, pinfo, isup_tree, itu_isup_variant);
9961
0
    }
9962
0
    else
9963
0
      proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
9964
0
                                 PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
9965
0
                                 "No optional parameter present (Pointer: %u)", opt_parameter_pointer);
9966
0
  }
9967
0
  else if (message_type != MESSAGE_TYPE_CHARGE_INFO)
9968
0
    expert_add_info(pinfo, type_item, &ei_isup_message_type_no_optional_parameters);
9969
9970
  /* if there are calling/called number, we'll get them for the tap */
9971
0
  tap_rec->calling_number = tap_calling_number ? tap_calling_number : wmem_strdup(pinfo->pool, "");
9972
0
  tap_rec->called_number  = tap_called_number;
9973
0
  tap_rec->cause_value    = tap_cause_value;
9974
0
  tap_queue_packet(isup_tap, pinfo, tap_rec);
9975
9976
0
  decrement_dissection_depth(pinfo);
9977
0
}
9978
// NOLINTEND(misc-no-recursion)
9979
9980
// NOLINTBEGIN(misc-no-recursion)
9981
static void
9982
dissect_isup_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *isup_tree, uint8_t itu_isup_variant, uint32_t circuit_id)
9983
810
{
9984
810
  isup_tap_rec_t *tap_rec;
9985
9986
810
  tvbuff_t   *parameter_tvb;
9987
810
  tvbuff_t   *optional_parameter_tvb;
9988
810
  proto_tree *pass_along_tree;
9989
810
  proto_item *type_item = NULL;
9990
810
  int         offset, bufferlength;
9991
810
  uint32_t    message_type;
9992
810
  uint8_t     opt_parameter_pointer;
9993
810
  bool        opt_part_possible = false; /* default setting - for message types allowing optional
9994
                                             params explicitly set to true in case statement */
9995
810
  tap_calling_number            = NULL;
9996
810
  offset                        = 0;
9997
9998
  // We call ourselves for MESSAGE_TYPE_PASS_ALONG.
9999
810
  increment_dissection_depth(pinfo);
10000
10001
  /* Extract message type field */
10002
810
  switch (itu_isup_variant) {
10003
810
    case ISUP_ITU_STANDARD_VARIANT:
10004
810
      type_item = proto_tree_add_item_ret_uint(isup_tree, hf_isup_message_type, message_tvb, 0, MESSAGE_TYPE_LENGTH, ENC_NA, &message_type);
10005
810
      break;
10006
0
    case ISUP_FRENCH_VARIANT:
10007
0
      type_item = proto_tree_add_item_ret_uint(isup_tree, hf_isup_message_type_french, message_tvb, 0, MESSAGE_TYPE_LENGTH, ENC_NA, &message_type);
10008
0
      break;
10009
0
    case ISUP_ISRAELI_VARIANT:
10010
0
      type_item = proto_tree_add_item_ret_uint(isup_tree, hf_isup_message_type_israeli, message_tvb, 0, MESSAGE_TYPE_LENGTH, ENC_NA, &message_type);
10011
0
      break;
10012
0
    case ISUP_RUSSIAN_VARIANT:
10013
0
      type_item = proto_tree_add_item_ret_uint(isup_tree, hf_isup_message_type_russian, message_tvb, 0, MESSAGE_TYPE_LENGTH, ENC_NA, &message_type);
10014
0
      break;
10015
0
  case ISUP_JAPAN_VARIANT:
10016
  /* Fall through */
10017
0
  case ISUP_JAPAN_TTC_VARIANT:
10018
0
      type_item = proto_tree_add_item_ret_uint(isup_tree, hf_isup_message_type_japan, message_tvb, 0, MESSAGE_TYPE_LENGTH, ENC_NA, &message_type);
10019
0
      break;
10020
0
  default:
10021
0
      DISSECTOR_ASSERT_NOT_REACHED();
10022
810
  }
10023
10024
810
  offset +=  MESSAGE_TYPE_LENGTH;
10025
10026
810
  tap_rec = wmem_new(pinfo->pool, isup_tap_rec_t);
10027
810
  tap_rec->message_type   = message_type;
10028
810
  tap_rec->itu_isup_variant = itu_isup_variant;
10029
810
  tap_rec->calling_number = NULL;
10030
810
  tap_rec->called_number  = NULL;
10031
810
  tap_rec->circuit_id     = circuit_id;
10032
10033
810
  parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);
10034
10035
  /* distinguish between message types:*/
10036
810
  switch (message_type) {
10037
120
    case MESSAGE_TYPE_INITIAL_ADDR:
10038
120
      offset += dissect_isup_initial_address_message(parameter_tvb, pinfo, isup_tree, itu_isup_variant);
10039
120
      opt_part_possible = true;
10040
120
      break;
10041
14
    case MESSAGE_TYPE_SUBSEQ_ADDR:
10042
14
      offset += dissect_isup_subsequent_address_message(parameter_tvb, pinfo, isup_tree);
10043
14
      opt_part_possible = true;
10044
14
      break;
10045
65
    case MESSAGE_TYPE_INFO_REQ:
10046
65
      offset += dissect_isup_information_request_message(parameter_tvb, isup_tree);
10047
65
      opt_part_possible = true;
10048
65
      break;
10049
16
    case MESSAGE_TYPE_INFO:
10050
16
      offset += dissect_isup_information_message(parameter_tvb, isup_tree);
10051
16
      opt_part_possible = true;
10052
16
      break;
10053
2
    case MESSAGE_TYPE_CONTINUITY:
10054
2
      offset += dissect_isup_continuity_message(parameter_tvb, isup_tree);
10055
2
      break;
10056
28
    case MESSAGE_TYPE_ADDR_CMPL:
10057
28
      offset += dissect_isup_address_complete_message(parameter_tvb, pinfo, isup_tree);
10058
28
      opt_part_possible = true;
10059
28
      break;
10060
103
    case MESSAGE_TYPE_CONNECT:
10061
103
      offset += dissect_isup_connect_message(parameter_tvb, pinfo, isup_tree);
10062
103
      opt_part_possible = true;
10063
103
      break;
10064
59
    case MESSAGE_TYPE_FORW_TRANS:
10065
      /* no dissector necessary since no mandatory parameters included */
10066
59
      opt_part_possible = true;
10067
59
      break;
10068
5
    case MESSAGE_TYPE_ANSWER:
10069
      /* no dissector necessary since no mandatory parameters included */
10070
5
      opt_part_possible = true;
10071
5
      break;
10072
14
    case MESSAGE_TYPE_RELEASE:
10073
14
      offset += dissect_isup_release_message(parameter_tvb, pinfo, isup_tree);
10074
14
      opt_part_possible = true;
10075
14
      break;
10076
37
    case MESSAGE_TYPE_SUSPEND:
10077
37
      offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
10078
37
      opt_part_possible = true;
10079
37
      break;
10080
16
    case MESSAGE_TYPE_RESUME:
10081
16
      offset += dissect_isup_suspend_resume_message(parameter_tvb, isup_tree);
10082
16
      opt_part_possible = true;
10083
16
      break;
10084
4
    case MESSAGE_TYPE_REL_CMPL:
10085
      /* no dissector necessary since no mandatory parameters included */
10086
4
      opt_part_possible = true;
10087
4
      break;
10088
2
    case MESSAGE_TYPE_CONT_CHECK_REQ:
10089
      /* no dissector necessary since no mandatory parameters included */
10090
2
      break;
10091
2
    case MESSAGE_TYPE_RESET_CIRCUIT:
10092
      /* no dissector necessary since no mandatory parameters included */
10093
2
      break;
10094
2
    case MESSAGE_TYPE_BLOCKING:
10095
      /* no dissector necessary since no mandatory parameters included */
10096
2
      break;
10097
1
    case MESSAGE_TYPE_UNBLOCKING:
10098
      /* no dissector necessary since no mandatory parameters included */
10099
1
      break;
10100
2
    case MESSAGE_TYPE_BLOCK_ACK:
10101
      /* no dissector necessary since no mandatory parameters included */
10102
2
      break;
10103
2
    case MESSAGE_TYPE_UNBLOCK_ACK:
10104
      /* no dissector necessary since no mandatory parameters included */
10105
2
      break;
10106
1
    case MESSAGE_TYPE_CIRC_GRP_RST:
10107
1
      offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, pinfo, isup_tree);
10108
1
      break;
10109
2
    case MESSAGE_TYPE_CIRC_GRP_BLCK:
10110
2
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
10111
2
      break;
10112
2
    case MESSAGE_TYPE_CIRC_GRP_UNBL:
10113
2
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
10114
2
      break;
10115
2
    case MESSAGE_TYPE_CIRC_GRP_BL_ACK:
10116
2
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
10117
2
      break;
10118
2
    case MESSAGE_TYPE_CIRC_GRP_UNBL_ACK:
10119
2
      offset += dissect_isup_circuit_group_blocking_messages(parameter_tvb, pinfo, isup_tree);
10120
2
      break;
10121
6
    case MESSAGE_TYPE_FACILITY_REQ:
10122
6
      offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
10123
6
      opt_part_possible = true;
10124
6
      break;
10125
19
    case MESSAGE_TYPE_FACILITY_ACC:
10126
19
      offset += dissect_isup_facility_request_accepted_message(parameter_tvb, isup_tree);
10127
19
      opt_part_possible = true;
10128
19
      break;
10129
18
    case MESSAGE_TYPE_FACILITY_REJ:
10130
18
      offset += dissect_isup_facility_reject_message(parameter_tvb, pinfo, isup_tree);
10131
18
      opt_part_possible = true;
10132
18
      break;
10133
2
    case MESSAGE_TYPE_LOOP_BACK_ACK:
10134
      /* no dissector necessary since no mandatory parameters included */
10135
2
      break;
10136
107
    case MESSAGE_TYPE_PASS_ALONG:
10137
      /* call dissect_isup_message recursively */
10138
107
    {
10139
107
      uint8_t pa_message_type;
10140
107
      pa_message_type = tvb_get_uint8(parameter_tvb, 0);
10141
107
      pass_along_tree = proto_tree_add_subtree_format(isup_tree, parameter_tvb, offset, -1,
10142
107
                                            ett_isup_pass_along_message, NULL,
10143
107
                                            "Pass-along: %s Message (%u)",
10144
107
                                            val_to_str_ext_const(pa_message_type, &isup_message_type_value_acro_ext, "reserved"),
10145
107
                                            pa_message_type);
10146
107
      dissect_isup_message(parameter_tvb, pinfo, pass_along_tree, itu_isup_variant, circuit_id);
10147
107
      break;
10148
0
    }
10149
2
    case MESSAGE_TYPE_CIRC_GRP_RST_ACK:
10150
2
      offset += dissect_isup_circuit_group_reset_acknowledgement_message(parameter_tvb, pinfo, isup_tree);
10151
2
      break;
10152
4
    case MESSAGE_TYPE_CIRC_GRP_QRY:
10153
4
      offset += dissect_isup_circuit_group_reset_query_message(parameter_tvb, pinfo, isup_tree);
10154
4
      break;
10155
8
    case MESSAGE_TYPE_CIRC_GRP_QRY_RSP:
10156
8
      offset += dissect_isup_circuit_group_query_response_message(parameter_tvb, pinfo, isup_tree);
10157
8
      break;
10158
3
    case MESSAGE_TYPE_CALL_PROGRSS:
10159
3
      offset += dissect_isup_call_progress_message(parameter_tvb, isup_tree);
10160
3
      opt_part_possible = true;
10161
3
      break;
10162
17
    case MESSAGE_TYPE_USER2USER_INFO:
10163
17
      offset += dissect_isup_user_to_user_information_message(parameter_tvb, pinfo, isup_tree);
10164
17
      opt_part_possible = true;
10165
17
      break;
10166
2
    case MESSAGE_TYPE_UNEQUIPPED_CIC:
10167
      /* no dissector necessary since no mandatory parameters included */
10168
2
      break;
10169
4
    case MESSAGE_TYPE_CONFUSION:
10170
4
      offset += dissect_isup_confusion_message(parameter_tvb, pinfo, isup_tree);
10171
4
      opt_part_possible = true;
10172
4
      break;
10173
2
    case MESSAGE_TYPE_OVERLOAD:
10174
      /* no dissector necessary since no mandatory parameters included */
10175
2
      break;
10176
2
    case MESSAGE_TYPE_CHARGE_INFO:
10177
      /* do nothing since format is a national matter */
10178
2
      bufferlength = tvb_reported_length_remaining(message_tvb, offset);
10179
2
      if (bufferlength != 0) {
10180
2
        switch (itu_isup_variant) {
10181
0
          case ISUP_RUSSIAN_VARIANT:
10182
0
            proto_tree_add_expert(isup_tree, pinfo, &ei_isup_format_national_matter, parameter_tvb, 0, bufferlength);
10183
0
            break;
10184
2
          default:
10185
2
            proto_tree_add_expert(isup_tree, pinfo, &ei_isup_format_national_matter, parameter_tvb, 0, bufferlength);
10186
2
            break;
10187
2
        }
10188
2
      }
10189
2
      break;
10190
10
    case MESSAGE_TYPE_NETW_RESRC_MGMT:
10191
      /* no dissector necessary since no mandatory parameters included */
10192
10
      opt_part_possible = true;
10193
10
      break;
10194
14
    case MESSAGE_TYPE_FACILITY:
10195
      /* no dissector necessary since no mandatory parameters included */
10196
14
      opt_part_possible = true;
10197
14
      break;
10198
11
    case MESSAGE_TYPE_USER_PART_TEST:
10199
      /* no dissector necessary since no mandatory parameters included */
10200
11
      opt_part_possible = true;
10201
11
      break;
10202
32
    case MESSAGE_TYPE_USER_PART_AVAIL:
10203
      /* no dissector necessary since no mandatory parameters included */
10204
32
      opt_part_possible = true;
10205
32
      break;
10206
3
    case MESSAGE_TYPE_IDENT_REQ:
10207
      /* no dissector necessary since no mandatory parameters included */
10208
3
      opt_part_possible = true;
10209
3
      break;
10210
6
    case MESSAGE_TYPE_IDENT_RSP:
10211
      /* no dissector necessary since no mandatory parameters included */
10212
6
      opt_part_possible = true;
10213
6
      break;
10214
11
    case MESSAGE_TYPE_SEGMENTATION:
10215
      /* no dissector necessary since no mandatory parameters included */
10216
11
      opt_part_possible = true;
10217
11
      break;
10218
2
    case MESSAGE_TYPE_LOOP_PREVENTION:
10219
      /* no dissector necessary since no mandatory parameters included */
10220
2
      opt_part_possible = true;
10221
2
      break;
10222
3
    case MESSAGE_TYPE_APPLICATION_TRANS:
10223
      /* no dissector necessary since no mandatory parameters included */
10224
3
      opt_part_possible = true;
10225
3
      break;
10226
5
    case MESSAGE_TYPE_PRE_RELEASE_INFO:
10227
      /* no dissector necessary since no mandatory parameters included */
10228
5
      opt_part_possible = true;
10229
5
      break;
10230
1
    case MESSAGE_TYPE_SUBSEQUENT_DIR_NUM:
10231
      /* do nothing since format is a national matter */
10232
1
      bufferlength = tvb_reported_length_remaining(message_tvb, offset);
10233
1
      if (bufferlength != 0)
10234
1
         proto_tree_add_expert(isup_tree, pinfo, &ei_isup_format_national_matter, parameter_tvb, 0, bufferlength);
10235
1
      break;
10236
13
    default:
10237
      /* Handle national extensions here */
10238
13
      switch (itu_isup_variant) {
10239
13
        case ISUP_ITU_STANDARD_VARIANT:
10240
13
          bufferlength = tvb_reported_length_remaining(message_tvb, offset);
10241
13
          if (bufferlength != 0)
10242
11
            expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
10243
13
          break;
10244
0
        case ISUP_FRENCH_VARIANT:
10245
0
          switch (message_type) {
10246
0
            case FRENCH_CHARGING_PULSE:
10247
0
              offset += dissect_french_isup_charging_pulse_message(parameter_tvb, isup_tree);
10248
0
              opt_part_possible = true;
10249
0
              break;
10250
0
            case FRENCH_CHARGING_ACK:
10251
0
              opt_part_possible = true;
10252
0
              break;
10253
0
            default:
10254
0
              bufferlength = tvb_reported_length_remaining(message_tvb, offset);
10255
0
              if (bufferlength != 0)
10256
0
                expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
10257
0
              break;
10258
0
          }
10259
0
          break;
10260
0
        case ISUP_ISRAELI_VARIANT:
10261
0
          switch (message_type) {
10262
0
            case ISRAELI_BACKWARD_CHARGING:
10263
0
              offset += dissect_israeli_backward_charging_message(parameter_tvb, isup_tree);
10264
0
              break;
10265
0
            case ISRAELI_TRAFFIC_CHANGE:
10266
0
              offset += dissect_israeli_traffic_change_message(parameter_tvb, isup_tree);
10267
0
              break;
10268
0
            case ISRAELI_CHARGE_ACK:
10269
              /* No parameters */
10270
0
              break;
10271
0
            default:
10272
0
              bufferlength = tvb_reported_length_remaining(message_tvb, offset);
10273
0
              if (bufferlength != 0)
10274
0
                expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
10275
0
              break;
10276
0
          }
10277
0
          break;
10278
0
        case ISUP_RUSSIAN_VARIANT:
10279
0
          switch (message_type) {
10280
0
            case RUSSIAN_CLEAR_CALLING_LINE:
10281
              /* no dissector necessary since no mandatory parameters included */
10282
0
              break;
10283
0
            case RUSSIAN_RINGING:
10284
              /* no dissector necessary since no mandatory parameters included */
10285
0
              opt_part_possible = true;
10286
0
              break;
10287
0
            default:
10288
0
              bufferlength = tvb_reported_length_remaining(message_tvb, offset);
10289
0
              if (bufferlength != 0)
10290
0
                expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
10291
0
              break;
10292
0
          }
10293
0
          break;
10294
0
        case ISUP_JAPAN_VARIANT:
10295
        /* Fall through */
10296
0
        case ISUP_JAPAN_TTC_VARIANT:
10297
0
          switch (message_type) {
10298
0
            case MESSAGE_TYPE_JAPAN_CHARG_INF:
10299
0
              offset += dissect_japan_chg_inf(parameter_tvb, pinfo, isup_tree);
10300
0
              opt_part_possible = true;
10301
0
              break;
10302
0
            default:
10303
0
              bufferlength = tvb_reported_length_remaining(message_tvb, offset);
10304
0
              if (bufferlength != 0)
10305
0
                expert_add_info(pinfo, type_item, &ei_isup_message_type_unknown);
10306
0
              break;
10307
0
          }
10308
0
          break;
10309
13
      } /* switch (itu_isup_variant) */
10310
13
      break;
10311
810
  }
10312
10313
  /* extract pointer to start of optional part (if any) */
10314
765
  if (opt_part_possible == true) {
10315
638
    opt_parameter_pointer = tvb_get_uint8(message_tvb, offset);
10316
638
    if (opt_parameter_pointer > 0) {
10317
634
      proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
10318
634
                                 PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
10319
634
                                 "Pointer to start of optional part: %u", opt_parameter_pointer);
10320
634
      offset += opt_parameter_pointer;
10321
634
      optional_parameter_tvb = tvb_new_subset_remaining(message_tvb, offset);
10322
634
      dissect_isup_optional_parameter(optional_parameter_tvb, pinfo, isup_tree, itu_isup_variant);
10323
634
    }
10324
4
    else
10325
4
      proto_tree_add_uint_format(isup_tree, hf_isup_pointer_to_start_of_optional_part, message_tvb, offset,
10326
4
                                 PARAMETER_POINTER_LENGTH, opt_parameter_pointer,
10327
4
                                 "No optional parameter present (Pointer: %u)", opt_parameter_pointer);
10328
638
  }
10329
127
  else if (message_type != MESSAGE_TYPE_CHARGE_INFO)
10330
125
    expert_add_info(pinfo, type_item, &ei_isup_message_type_no_optional_parameters);
10331
10332
  /* if there are calling/called number, we'll get them for the tap */
10333
765
  tap_rec->calling_number = tap_calling_number ? tap_calling_number : wmem_strdup(pinfo->pool, "");
10334
765
  tap_rec->called_number  = tap_called_number;
10335
765
  tap_rec->cause_value    = tap_cause_value;
10336
765
  tap_queue_packet(isup_tap, pinfo, tap_rec);
10337
10338
765
  decrement_dissection_depth(pinfo);
10339
765
}
10340
// NOLINTEND(misc-no-recursion)
10341
10342
/* ------------------------------------------------------------------ */
10343
static int
10344
dissect_isup(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
10345
150
{
10346
10347
/* Set up structures needed to add the protocol subtree and manage it */
10348
150
  proto_item       *ti;
10349
150
  proto_tree       *isup_tree = NULL;
10350
150
  tvbuff_t         *message_tvb;
10351
150
  uint16_t          cic;
10352
150
  uint8_t           message_type;
10353
150
  uint8_t           itu_isup_variant = g_isup_variant;
10354
150
  value_string_ext *used_value_string_ext;
10355
10356
/* Make entries in Protocol column and Info column on summary display */
10357
/* dissect CIC in main dissector since pass-along message type carrying complete IUSP message w/o CIC needs
10358
 *    recursive message dissector call
10359
 */
10360
/* Extract message type field */
10361
150
  message_type = tvb_get_uint8(tvb, CIC_OFFSET + CIC_LENGTH);
10362
10363
150
  switch (mtp3_standard) {
10364
0
    case ANSI_STANDARD:
10365
0
      isup_standard = ANSI_STANDARD;
10366
0
      col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(ANSI)");
10367
0
      cic = tvb_get_letohs(tvb, CIC_OFFSET) & 0x3FFF; /*since upper 2 bits spare */
10368
0
      if (isup_show_cic_in_info) {
10369
0
        col_add_fstr(pinfo->cinfo, COL_INFO,
10370
0
                     "%s (CIC %u) ",
10371
0
                     val_to_str_ext_const(message_type, &ansi_isup_message_type_value_acro_ext, "reserved"),
10372
0
                     cic);
10373
0
      } else {
10374
0
        col_add_fstr(pinfo->cinfo, COL_INFO, "%s ",
10375
0
                     val_to_str_ext_const(message_type, &ansi_isup_message_type_value_acro_ext, "reserved"));
10376
0
      }
10377
0
      if (tree) {
10378
0
        ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, ENC_NA);
10379
0
        isup_tree = proto_item_add_subtree(ti, ett_isup);
10380
0
        proto_tree_add_uint(isup_tree, hf_isup_cic, tvb, CIC_OFFSET, CIC_LENGTH, cic);
10381
0
      }
10382
0
      conversation_set_elements_by_id(pinfo, CONVERSATION_ISUP, cic);
10383
0
      message_tvb = tvb_new_subset_remaining(tvb, CIC_LENGTH);
10384
0
      dissect_ansi_isup_message(message_tvb, pinfo, isup_tree, ISUP_ITU_STANDARD_VARIANT, cic);
10385
0
      break;
10386
150
    default:
10387
150
      isup_standard = ITU_STANDARD;
10388
      /* ITU, China, and Japan; yes, J7's CICs are a different size */
10389
150
      cic = tvb_get_letohs(tvb, CIC_OFFSET) & 0x0FFF; /*since upper 4 bits spare */
10390
150
      switch (itu_isup_variant) {
10391
0
        case ISUP_FRENCH_VARIANT:
10392
0
          col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(French)");
10393
0
          used_value_string_ext = &french_isup_message_type_value_acro_ext;
10394
0
          break;
10395
0
        case ISUP_ISRAELI_VARIANT:
10396
0
          col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(Israeli)");
10397
0
          used_value_string_ext = &israeli_isup_message_type_value_acro_ext;
10398
0
          break;
10399
0
        case ISUP_RUSSIAN_VARIANT:
10400
0
          col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(Russian)");
10401
0
          used_value_string_ext = &russian_isup_message_type_value_acro_ext;
10402
0
          break;
10403
0
        case ISUP_JAPAN_VARIANT:
10404
0
          col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(Japan)");
10405
0
          used_value_string_ext = &japan_isup_message_type_value_acro_ext;
10406
0
          break;
10407
0
        case ISUP_JAPAN_TTC_VARIANT:
10408
0
          col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(Japan TTC)");
10409
0
          used_value_string_ext = &japan_isup_message_type_value_acro_ext;
10410
0
          cic = tvb_get_letohs(tvb, CIC_OFFSET) & 0x1FFF; /*since upper 3 bits spare */
10411
0
          break;
10412
150
        default:
10413
150
          col_set_str(pinfo->cinfo, COL_PROTOCOL, "ISUP(ITU)");
10414
150
          used_value_string_ext = &isup_message_type_value_acro_ext;
10415
150
          break;
10416
150
      }
10417
150
      if (isup_show_cic_in_info) {
10418
150
        col_add_fstr(pinfo->cinfo, COL_INFO,
10419
150
                     "%s (CIC %u) ",
10420
150
                     val_to_str_ext_const(message_type, used_value_string_ext, "reserved"),
10421
150
                     cic);
10422
150
      } else {
10423
0
        col_add_fstr(pinfo->cinfo, COL_INFO, "%s ",
10424
0
                     val_to_str_ext_const(message_type, used_value_string_ext, "reserved"));
10425
0
      }
10426
150
      if (tree) {
10427
150
        ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, ENC_NA);
10428
150
        isup_tree = proto_item_add_subtree(ti, ett_isup);
10429
150
        proto_tree_add_uint(isup_tree, hf_isup_cic, tvb, CIC_OFFSET, CIC_LENGTH, cic);
10430
150
      }
10431
150
      conversation_set_elements_by_id(pinfo, CONVERSATION_ISUP, cic);
10432
150
      message_tvb = tvb_new_subset_remaining(tvb, CIC_LENGTH);
10433
150
      dissect_isup_message(message_tvb, pinfo, isup_tree, itu_isup_variant, cic);
10434
150
  }
10435
105
  return tvb_captured_length(tvb);
10436
150
}
10437
10438
/* ------------------------------------------------------------------ */
10439
static int
10440
dissect_bicc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
10441
553
{
10442
10443
/* Set up structures needed to add the protocol subtree and manage it */
10444
553
  proto_item       *ti;
10445
553
  proto_tree       *bicc_tree = NULL;
10446
553
  tvbuff_t         *message_tvb;
10447
553
  uint32_t          bicc_cic;
10448
553
  uint8_t           message_type;
10449
553
  uint8_t           itu_isup_variant = g_isup_variant;
10450
553
  value_string_ext *used_value_string_ext;
10451
10452
  /*circuit_t *circuit;*/
10453
10454
/* Make entries in Protocol column and Info column on summary display */
10455
553
  switch (itu_isup_variant) {
10456
0
    case ISUP_FRENCH_VARIANT:
10457
0
      col_set_str(pinfo->cinfo, COL_PROTOCOL, "BICC(French)");
10458
0
      used_value_string_ext = &french_isup_message_type_value_acro_ext;
10459
0
      break;
10460
0
    case ISUP_ISRAELI_VARIANT:
10461
0
      col_set_str(pinfo->cinfo, COL_PROTOCOL, "BICC(Israeli)");
10462
0
      used_value_string_ext = &israeli_isup_message_type_value_acro_ext;
10463
0
      break;
10464
0
    case ISUP_RUSSIAN_VARIANT:
10465
0
      col_set_str(pinfo->cinfo, COL_PROTOCOL, "BICC(Russian)");
10466
0
      used_value_string_ext = &russian_isup_message_type_value_acro_ext;
10467
0
      break;
10468
0
    case ISUP_JAPAN_VARIANT:
10469
    /* Fall through */
10470
0
    case ISUP_JAPAN_TTC_VARIANT:
10471
0
      col_set_str(pinfo->cinfo, COL_PROTOCOL, "BICC(Japan)");
10472
0
      used_value_string_ext = &japan_isup_message_type_value_acro_ext;
10473
0
      break;
10474
553
    default:
10475
553
      col_set_str(pinfo->cinfo, COL_PROTOCOL, "BICC(ITU)");
10476
553
      used_value_string_ext = &isup_message_type_value_acro_ext;
10477
553
      break;
10478
553
  }
10479
10480
/* Extract message type field */
10481
553
  message_type = tvb_get_uint8(tvb, BICC_CIC_OFFSET + BICC_CIC_LENGTH);
10482
10483
553
  bicc_cic = tvb_get_letohl(tvb, BICC_CIC_OFFSET);
10484
10485
553
  conversation_set_elements_by_id(pinfo, CONVERSATION_BICC, bicc_cic);
10486
10487
553
  col_clear(pinfo->cinfo, COL_INFO);
10488
553
  if (isup_show_cic_in_info) {
10489
553
    col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
10490
553
                        "%s (CIC %u)",
10491
553
                        val_to_str_ext_const(message_type, used_value_string_ext, "reserved"),
10492
553
                        bicc_cic);
10493
553
  } else {
10494
0
    col_append_sep_str(pinfo->cinfo, COL_INFO, ", ",
10495
0
                        val_to_str_ext_const(message_type, used_value_string_ext, "reserved"));
10496
0
  }
10497
  /* dissect CIC in main dissector since pass-along message type carrying complete BICC/ISUP message w/o CIC needs
10498
   * recursive message dissector call
10499
   */
10500
553
  if (tree) {
10501
553
    ti = proto_tree_add_item(tree, proto_bicc, tvb, 0, -1, ENC_NA);
10502
553
    bicc_tree = proto_item_add_subtree(ti, ett_bicc);
10503
10504
10505
553
    proto_tree_add_uint_format(bicc_tree, hf_bicc_cic, tvb, BICC_CIC_OFFSET, BICC_CIC_LENGTH,
10506
553
                               bicc_cic, "CIC: %u", bicc_cic);
10507
553
  }
10508
10509
553
  message_tvb = tvb_new_subset_remaining(tvb, BICC_CIC_LENGTH);
10510
553
  dissect_isup_message(message_tvb, pinfo, bicc_tree, itu_isup_variant, bicc_cic);
10511
553
  col_set_fence(pinfo->cinfo, COL_INFO);
10512
553
  return tvb_captured_length(tvb);
10513
553
}
10514
10515
static int
10516
dissect_application_isup(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
10517
0
{
10518
/* Set up structures needed to add the protocol subtree and manage it */
10519
0
  proto_item *ti;
10520
0
  proto_tree *isup_tree = NULL;
10521
0
  tvbuff_t   *message_tvb;
10522
0
  uint8_t     message_type;
10523
0
  char       *version, *base;
10524
0
  uint8_t     itu_isup_variant = ISUP_ITU_STANDARD_VARIANT; /* Default */
10525
10526
0
  if (data) {
10527
0
    media_content_info_t *content_info = (media_content_info_t *)data;
10528
0
    if (content_info->media_str) {
10529
0
      version = ws_find_media_type_parameter(pinfo->pool, content_info->media_str, "version");
10530
0
      base = ws_find_media_type_parameter(pinfo->pool, content_info->media_str, "base");
10531
0
      if ((version && g_ascii_strncasecmp(version, "ansi", 4) == 0) ||
10532
0
          (base && g_ascii_strncasecmp(base, "ansi", 4) == 0) ||
10533
0
          (version && g_ascii_strncasecmp(version, "gr", 2) == 0) ||
10534
0
          (base && g_ascii_strncasecmp(base, "gr", 2) == 0)) {
10535
        /*
10536
         * "version" or "base" parameter begins with "ansi" or "gr", so it's
10537
         * ANSI or Bellcore.
10538
         */
10539
0
        isup_standard = ANSI_STANDARD;
10540
0
        col_append_str(pinfo->cinfo, COL_PROTOCOL, "/ISUP(ANSI)");
10541
0
        message_type = tvb_get_uint8(tvb, 0);
10542
        /* application/ISUP has no  CIC  */
10543
0
        col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
10544
0
                            "ISUP:%s",
10545
0
                            val_to_str_ext_const(message_type, &ansi_isup_message_type_value_acro_ext, "reserved"));
10546
0
        if (tree) {
10547
0
          ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, ENC_NA);
10548
0
          isup_tree = proto_item_add_subtree(ti, ett_isup);
10549
0
        }
10550
10551
0
        message_tvb = tvb_new_subset_remaining(tvb, 0);
10552
0
        dissect_ansi_isup_message(message_tvb, pinfo, isup_tree, ISUP_ITU_STANDARD_VARIANT, 0);
10553
0
        return tvb_reported_length(tvb);
10554
0
      } else if ((version && g_ascii_strcasecmp(version, "spirou") == 0) ||
10555
0
          (base && g_ascii_strcasecmp(base, "spirou") == 0)) {
10556
        /*
10557
         * "version" or "base" version is "spirou", so it's SPIROU.
10558
         */
10559
0
        isup_standard    = ITU_STANDARD;
10560
0
        itu_isup_variant = ISUP_FRENCH_VARIANT;
10561
0
      } else {
10562
0
        isup_standard = ITU_STANDARD;
10563
0
      }
10564
0
    } else {
10565
      /* default to ITU */
10566
0
      isup_standard = ITU_STANDARD;
10567
0
    }
10568
0
  } else {
10569
    /* default to ITU */
10570
0
    isup_standard = ITU_STANDARD;
10571
0
  }
10572
10573
10574
  /* Extract message type field */
10575
0
  message_type = tvb_get_uint8(tvb, 0);
10576
10577
0
  switch (itu_isup_variant) {
10578
0
    case ISUP_ITU_STANDARD_VARIANT:
10579
      /* Make entries in Protocol column and Info column on summary display */
10580
0
      col_append_str(pinfo->cinfo, COL_PROTOCOL, "/ISUP(ITU)");
10581
10582
      /* application/ISUP has no  CIC  */
10583
0
      col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
10584
0
                          "ISUP:%s",
10585
0
                          val_to_str_ext_const(message_type, &isup_message_type_value_acro_ext, "reserved"));
10586
0
      break;
10587
0
    case ISUP_FRENCH_VARIANT:
10588
      /* Make entries in Protocol column and Info column on summary display */
10589
0
      col_append_str(pinfo->cinfo, COL_PROTOCOL, "/ISUP(French)");
10590
10591
      /* application/ISUP has no  CIC  */
10592
0
      col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
10593
0
                          "ISUP:%s",
10594
0
                          val_to_str_ext_const(message_type, &french_isup_message_type_value_acro_ext, "reserved"));
10595
0
      break;
10596
#if 0
10597
      /* This case can't happen unless/until we can parse the Israeli variant
10598
       * out of the content type
10599
       */
10600
    case ISUP_ISRAELI_VARIANT:
10601
      /* Make entries in Protocol column and Info column on summary display */
10602
      col_append_str(pinfo->cinfo, COL_PROTOCOL, "/ISUP(Israeli)");
10603
10604
      /* application/ISUP has no  CIC  */
10605
      col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
10606
                          "ISUP:%s",
10607
                          val_to_str_ext_const(message_type, &israeli_isup_message_type_value_acro_ext, "reserved"));
10608
      break;
10609
#endif
10610
0
    default:
10611
0
      col_append_sep_fstr(pinfo->cinfo, COL_INFO, ", ",
10612
0
                          "ISUP: Unknown variant %d", itu_isup_variant);
10613
0
      break;
10614
0
  }
10615
10616
0
  if (tree) {
10617
0
    ti = proto_tree_add_item(tree, proto_isup, tvb, 0, -1, ENC_NA);
10618
0
    isup_tree = proto_item_add_subtree(ti, ett_isup);
10619
0
  }
10620
10621
0
  message_tvb = tvb_new_subset_remaining(tvb, 0);
10622
0
  dissect_isup_message(message_tvb, pinfo, isup_tree, itu_isup_variant, 0);
10623
0
  return tvb_reported_length(tvb);
10624
0
}
10625
/* ---------------------------------------------------- stats tree
10626
*/
10627
static int st_node_msg = -1;
10628
static int st_node_dir = -1;
10629
10630
static void
10631
msg_stats_tree_init(stats_tree *st)
10632
0
{
10633
0
  st_node_msg = stats_tree_create_node(st, "Messages by Type", 0, STAT_DT_INT, true);
10634
0
  st_node_dir = stats_tree_create_node(st, "Messages by Direction", 0, STAT_DT_INT, true);
10635
0
}
10636
10637
static tap_packet_status
10638
msg_stats_tree_packet(stats_tree *st, packet_info *pinfo, epan_dissect_t *edt _U_, const void *p, tap_flags_t flags _U_)
10639
0
{
10640
0
  const isup_tap_rec_t *tap_rec = (const isup_tap_rec_t *)p;
10641
0
  const char *msg;
10642
0
  char        *src, *dst, *dir;
10643
0
  int          msg_node;
10644
0
  int          dir_node;
10645
0
  value_string_ext *used_value_string_ext;
10646
10647
0
  switch (tap_rec->itu_isup_variant) {
10648
0
    case ISUP_FRENCH_VARIANT:
10649
0
      used_value_string_ext = &french_isup_message_type_value_acro_ext;
10650
0
      break;
10651
0
    case ISUP_ISRAELI_VARIANT:
10652
0
      used_value_string_ext = &israeli_isup_message_type_value_acro_ext;
10653
0
      break;
10654
0
    case ISUP_RUSSIAN_VARIANT:
10655
0
      used_value_string_ext = &russian_isup_message_type_value_acro_ext;
10656
0
      break;
10657
0
    case ISUP_JAPAN_VARIANT:
10658
0
    case ISUP_JAPAN_TTC_VARIANT:
10659
0
      used_value_string_ext = &japan_isup_message_type_value_acro_ext;
10660
0
      break;
10661
0
    default:
10662
0
      used_value_string_ext = &isup_message_type_value_acro_ext;
10663
0
      break;
10664
0
  }
10665
0
  msg = val_to_str_ext_const(tap_rec->message_type, used_value_string_ext, "reserved");
10666
10667
0
  src = address_to_str(NULL, &pinfo->src);
10668
0
  dst = address_to_str(NULL, &pinfo->dst);
10669
0
  dir = wmem_strdup_printf(NULL, "%s->%s", src, dst);
10670
0
  wmem_free(NULL, src);
10671
0
  wmem_free(NULL, dst);
10672
10673
0
  msg_node = tick_stat_node(st, msg, st_node_msg, true);
10674
0
  tick_stat_node(st, dir, msg_node, false);
10675
10676
0
  dir_node = tick_stat_node(st, dir, st_node_dir, true);
10677
0
  tick_stat_node(st, msg, dir_node, false);
10678
10679
0
  wmem_free(NULL, dir);
10680
10681
0
  return TAP_PACKET_REDRAW;
10682
0
}
10683
10684
/*---------------------------------------------------------------------*/
10685
/* Register the protocol with Wireshark */
10686
void
10687
proto_register_isup(void)
10688
16
{
10689
/* Setup list of header fields  See Section 1.6.1 for details*/
10690
16
  static hf_register_info hf[] = {
10691
16
    { &hf_isup_cic,
10692
16
      { "CIC",           "isup.cic",
10693
16
        FT_UINT16, BASE_DEC, NULL, 0x0,
10694
16
        NULL, HFILL }},
10695
10696
16
    { &hf_isup_message_type,
10697
16
      { "Message Type",  "isup.message_type",
10698
16
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &isup_message_type_value_ext, 0x0,
10699
16
        NULL, HFILL }},
10700
10701
16
    { &hf_isup_message_type_ansi,
10702
16
      { "Message Type",  "isup.message_type",
10703
16
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &ansi_isup_message_type_value_ext, 0x0,
10704
16
        NULL, HFILL }},
10705
10706
16
    { &hf_isup_message_type_french,
10707
16
      { "Message Type",  "isup.message_type",
10708
16
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &french_isup_message_type_value_ext, 0x0,
10709
16
        NULL, HFILL }},
10710
10711
16
    { &hf_isup_message_type_israeli,
10712
16
      { "Message Type",  "isup.message_type",
10713
16
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &israeli_isup_message_type_value_ext, 0x0,
10714
16
        NULL, HFILL }},
10715
10716
16
    { &hf_isup_message_type_russian,
10717
16
      { "Message Type",  "isup.message_type",
10718
16
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &russian_isup_message_type_value_ext, 0x0,
10719
16
        NULL, HFILL }},
10720
10721
16
    { &hf_isup_message_type_japan,
10722
16
      { "Message Type",  "isup.message_type",
10723
16
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &japan_isup_message_type_value_ext, 0x0,
10724
16
        NULL, HFILL }},
10725
10726
16
    { &hf_isup_parameter_type,
10727
16
      { "Parameter Type",  "isup.parameter_type",
10728
16
        FT_UINT8, BASE_DEC, NULL, 0x0,
10729
16
        NULL, HFILL }},
10730
10731
16
    { &hf_isup_parameter_value,
10732
16
      { "Parameter Value",  "isup.parameter_value",
10733
16
        FT_BYTES, BASE_NONE, NULL, 0x0,
10734
16
        NULL, HFILL }},
10735
10736
16
    { &hf_isup_mand_parameter_type,
10737
16
      { "Mandatory Parameter",  "isup.parameter_type",
10738
16
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &isup_parameter_type_value_ext, 0x0,
10739
16
        NULL, HFILL }},
10740
10741
16
    { &hf_isup_opt_parameter_type,
10742
16
      { "Optional Parameter",  "isup.parameter_type",
10743
16
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &ansi_isup_parameter_type_value_ext, 0x0,
10744
16
        NULL, HFILL }},
10745
10746
16
    { &hf_isup_parameter_length,
10747
16
      { "Parameter Length",  "isup.parameter_length",
10748
16
        FT_UINT8, BASE_DEC, NULL, 0x0,
10749
16
        NULL, HFILL }},
10750
10751
16
    { &hf_isup_mandatory_variable_parameter_pointer,
10752
16
      { "Pointer to Parameter",  "isup.mandatory_variable_parameter_pointer",
10753
16
        FT_UINT8, BASE_DEC, NULL, 0x0,
10754
16
        NULL, HFILL }},
10755
10756
16
    { &hf_isup_pointer_to_start_of_optional_part,
10757
16
      { "Pointer to optional parameter part",  "isup.optional_parameter_part_pointer",
10758
16
        FT_UINT8, BASE_DEC, NULL, 0x0,
10759
16
        NULL, HFILL }},
10760
10761
16
    { &hf_isup_satellite_indicator,
10762
16
      { "Satellite Indicator",  "isup.satellite_indicator",
10763
16
        FT_UINT8, BASE_HEX, VALS(isup_satellite_ind_value), BA_8BIT_MASK,
10764
16
        NULL, HFILL }},
10765
10766
16
    { &hf_isup_continuity_check_indicator,
10767
16
      { "Continuity Check Indicator",  "isup.continuity_check_indicator",
10768
16
        FT_UINT8, BASE_HEX, VALS(isup_continuity_check_ind_value), DC_8BIT_MASK,
10769
16
        NULL, HFILL }},
10770
10771
16
    { &hf_isup_echo_control_device_indicator,
10772
16
      { "Echo Control Device Indicator",  "isup.echo_control_device_indicator",
10773
16
        FT_BOOLEAN, 8, TFS(&isup_echo_control_device_ind_value), E_8BIT_MASK,
10774
16
        NULL, HFILL }},
10775
10776
16
    { &hf_isup_forw_call_natnl_inatnl_call_indicator,
10777
16
      { "National/international call indicator",  "isup.forw_call_natnl_inatnl_call_indicator",
10778
16
        FT_BOOLEAN, 16, TFS(&isup_natnl_inatnl_call_ind_value), A_16BIT_MASK,
10779
16
        NULL, HFILL }},
10780
10781
16
    { &hf_isup_forw_call_end_to_end_method_indicator,
10782
16
      { "End-to-end method indicator",  "isup.forw_call_end_to_end_method_indicator",
10783
16
        FT_UINT16, BASE_HEX, VALS(isup_end_to_end_method_ind_value), CB_16BIT_MASK,
10784
16
        NULL, HFILL }},
10785
10786
16
    { &hf_isup_forw_call_interworking_indicator,
10787
16
      { "Interworking indicator",  "isup.forw_call_interworking_indicator",
10788
16
        FT_BOOLEAN, 16, TFS(&isup_interworking_ind_value), D_16BIT_MASK,
10789
16
        NULL, HFILL }},
10790
10791
16
    { &hf_isup_forw_call_end_to_end_info_indicator,
10792
16
      { "End-to-end information indicator",  "isup.forw_call_end_to_end_information_indicator",
10793
16
        FT_BOOLEAN, 16, TFS(&isup_end_to_end_info_ind_value), E_16BIT_MASK,
10794
16
        NULL, HFILL }},
10795
10796
16
    { &hf_isup_forw_call_isdn_user_part_indicator,
10797
16
      { "ISDN user part indicator",  "isup.forw_call_isdn_user_part_indicator",
10798
16
        FT_BOOLEAN, 16, TFS(&isup_ISDN_user_part_ind_value), F_16BIT_MASK,
10799
16
        NULL, HFILL }},
10800
10801
16
    { &hf_isup_forw_call_preferences_indicator,
10802
16
      { "ISDN user part preference indicator",  "isup.forw_call_preferences_indicator",
10803
16
        FT_UINT16, BASE_HEX, VALS(isup_preferences_ind_value), HG_16BIT_MASK,
10804
16
        NULL, HFILL }},
10805
10806
16
    { &hf_isup_forw_call_isdn_access_indicator,
10807
16
      { "ISDN access indicator",  "isup.forw_call_isdn_access_indicator",
10808
16
        FT_BOOLEAN, 16, TFS(&isup_ISDN_originating_access_ind_value), I_16BIT_MASK,
10809
16
        NULL, HFILL }},
10810
10811
16
    { &hf_isup_forw_call_sccp_method_indicator,
10812
16
      { "SCCP method indicator",  "isup.forw_call_sccp_method_indicator",
10813
16
        FT_UINT16, BASE_HEX, VALS(isup_SCCP_method_ind_value), KJ_16BIT_MASK,
10814
16
        NULL, HFILL }},
10815
10816
16
    { &hf_isup_forw_call_ported_num_trans_indicator,
10817
16
      { "Ported number translation indicator",  "isup.forw_call_ported_num_trans_indicator",
10818
16
        FT_BOOLEAN, 16, TFS(&isup_ISDN_ported_num_trans_ind_value), M_16BIT_MASK,
10819
16
        NULL, HFILL }},
10820
10821
16
    { &hf_isup_forw_call_qor_attempt_indicator,
10822
16
      { "Query on Release attempt indicator",  "isup.forw_call_qor_attempt_indicator",
10823
16
        FT_BOOLEAN, 16, TFS(&isup_ISDN_qor_attempt_ind_value), N_16BIT_MASK,
10824
16
        NULL, HFILL }},
10825
10826
16
    { &hf_isup_calling_partys_category,
10827
16
      { "Calling Party's category",  "isup.calling_partys_category",
10828
16
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &isup_calling_partys_category_value_ext, 0x0,
10829
16
        NULL, HFILL }},
10830
10831
16
    { &hf_russian_isup_calling_partys_category,
10832
16
      { "Calling Party's category",  "isup.russian.calling_partys_category",
10833
16
        FT_UINT8, BASE_HEX, VALS(isup_calling_partys_category_value), 0x0,
10834
16
        NULL, HFILL }},
10835
10836
16
    { &hf_isup_transmission_medium_requirement,
10837
16
      { "Transmission medium requirement",  "isup.transmission_medium_requirement",
10838
16
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &isup_transmission_medium_requirement_value_ext, 0x0,
10839
16
        NULL, HFILL }},
10840
10841
16
    { &hf_isup_odd_even_indicator,
10842
16
      { "Odd/even indicator",  "isup.isdn_odd_even_indicator",
10843
16
        FT_BOOLEAN, 8, TFS(&isup_odd_even_ind_value), ISUP_ODD_EVEN_MASK,
10844
16
        NULL, HFILL }},
10845
10846
16
    { &hf_isup_generic_name_presentation,
10847
16
      { "Presentation indicator",  "isup.isdn_generic_name_presentation",
10848
16
        FT_UINT8, BASE_DEC, VALS(isup_generic_name_presentation_value), BA_8BIT_MASK,
10849
16
        NULL, HFILL }},
10850
10851
16
    { &hf_isup_generic_name_availability,
10852
16
      { "Availability indicator",  "isup.isdn_generic_name_availability",
10853
16
        FT_BOOLEAN, 8, TFS(&isup_generic_name_availability_value), E_8BIT_MASK,
10854
16
        NULL, HFILL }},
10855
10856
16
    { &hf_isup_generic_name_type,
10857
16
      { "Type indicator",  "isup.isdn_generic_name_type",
10858
16
        FT_UINT8, BASE_DEC, VALS(isup_generic_name_type_value), HGF_8BIT_MASK,
10859
16
        NULL, HFILL }},
10860
10861
16
    { &hf_isup_generic_name_ia5,
10862
16
      { "Generic Name",  "isup.isdn_generic_name_ia5",
10863
16
        FT_STRING, BASE_NONE, NULL, 0x0,
10864
16
        NULL, HFILL }},
10865
10866
16
    { &hf_isup_called_party_nature_of_address_indicator,
10867
16
      { "Nature of address indicator",  "isup.called_party_nature_of_address_indicator",
10868
16
        FT_UINT8, BASE_DEC, VALS(isup_called_party_nature_of_address_ind_value), ISUP_NATURE_OF_ADDRESS_IND_MASK,
10869
16
        NULL, HFILL }},
10870
10871
16
    { &hf_isup_calling_party_nature_of_address_indicator,
10872
16
      { "Nature of address indicator",  "isup.calling_party_nature_of_address_indicator",
10873
16
        FT_UINT8, BASE_DEC, VALS(isup_calling_party_nature_of_address_ind_value), ISUP_NATURE_OF_ADDRESS_IND_MASK,
10874
16
        NULL, HFILL }},
10875
10876
16
    { &hf_isup_charge_number_nature_of_address_indicator,
10877
16
      { "Nature of address indicator",  "isup.charge_number_nature_of_address_indicator",
10878
16
        FT_UINT8, BASE_DEC, VALS(isup_charge_number_nature_of_address_ind_value), ISUP_NATURE_OF_ADDRESS_IND_MASK,
10879
16
        NULL, HFILL }},
10880
10881
16
    { &hf_isup_inn_indicator,
10882
16
      { "INN indicator",  "isup.inn_indicator",
10883
16
        FT_BOOLEAN, 8, TFS(&isup_INN_ind_value), ISUP_INN_MASK,
10884
16
        NULL, HFILL }},
10885
10886
16
    { &hf_isup_ni_indicator,
10887
16
      { "NI indicator",  "isup.ni_indicator",
10888
16
        FT_BOOLEAN, 8, TFS(&isup_NI_ind_value), ISUP_NI_MASK,
10889
16
        NULL, HFILL }},
10890
10891
16
    { &hf_isup_numbering_plan_indicator,
10892
16
      { "Numbering plan indicator",  "isup.numbering_plan_indicator",
10893
16
        FT_UINT8, BASE_DEC, VALS(isup_numbering_plan_ind_value), ISUP_NUMBERING_PLAN_IND_MASK,
10894
16
        NULL, HFILL }},
10895
10896
16
    { &hf_isup_address_presentation_restricted_indicator,
10897
16
      { "Address presentation restricted indicator",  "isup.address_presentation_restricted_indicator",
10898
16
        FT_UINT8, BASE_DEC, VALS(isup_address_presentation_restricted_ind_value), ISUP_ADDRESS_PRESENTATION_RESTR_IND_MASK,
10899
16
        NULL, HFILL }},
10900
10901
16
    { &hf_isup_number_different_meaning,
10902
16
      { "Different meaning for number",  "isup.number_different_meaning",
10903
16
        FT_UINT8, BASE_HEX, NULL, 0,
10904
16
        NULL, HFILL }},
10905
10906
16
    { &hf_isup_screening_indicator,
10907
16
      { "Screening indicator",  "isup.screening_indicator",
10908
16
        FT_UINT8, BASE_DEC, VALS(isup_screening_ind_value), ISUP_SCREENING_IND_MASK,
10909
16
        NULL, HFILL }},
10910
10911
16
    { &hf_isup_screening_indicator_enhanced,
10912
16
      { "Screening indicator",  "isup.screening_indicator_enhanced",
10913
16
        FT_UINT8, BASE_DEC, VALS(isup_screening_ind_enhanced_value), ISUP_SCREENING_IND_MASK,
10914
16
        NULL, HFILL }},
10915
10916
16
    { &hf_isup_called_party_odd_address_signal_digit,
10917
16
      { "Address signal digit",  "isup.called_party_odd_address_signal_digit",
10918
16
        FT_UINT8, BASE_DEC | BASE_EXT_STRING, &isup_called_party_address_digit_value_ext, ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK,
10919
16
        NULL, HFILL }},
10920
10921
16
    { &hf_isup_calling_party_odd_address_signal_digit,
10922
16
      { "Address signal digit",  "isup.calling_party_odd_address_signal_digit",
10923
16
        FT_UINT8, BASE_DEC | BASE_EXT_STRING, &isup_calling_party_address_digit_value_ext, ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK,
10924
16
        NULL, HFILL }},
10925
10926
16
    { &hf_isup_called_party_even_address_signal_digit,
10927
16
      { "Address signal digit",  "isup.called_party_even_address_signal_digit",
10928
16
        FT_UINT8, BASE_DEC | BASE_EXT_STRING, &isup_called_party_address_digit_value_ext, ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK,
10929
16
        NULL, HFILL }},
10930
10931
16
    { &hf_isup_calling_party_even_address_signal_digit,
10932
16
      { "Address signal digit",  "isup.calling_party_even_address_signal_digit",
10933
16
        FT_UINT8, BASE_DEC | BASE_EXT_STRING, &isup_calling_party_address_digit_value_ext, ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK,
10934
16
        NULL, HFILL }},
10935
10936
16
    { &hf_isup_calling_party_address_request_indicator,
10937
16
      { "Calling party address request indicator",  "isup.calling_party_address_request_indicator",
10938
16
        FT_BOOLEAN, 16, TFS(&isup_calling_party_address_request_ind_value), A_16BIT_MASK,
10939
16
        NULL, HFILL }},
10940
10941
16
    { &hf_isup_info_req_holding_indicator,
10942
16
      { "Holding indicator",  "isup.info_req_holding_indicator",
10943
16
        FT_BOOLEAN, 16, TFS(&isup_holding_ind_value), B_16BIT_MASK,
10944
16
        NULL, HFILL }},
10945
10946
16
    { &hf_isup_calling_partys_category_request_indicator,
10947
16
      { "Calling party's category request indicator",  "isup.calling_partys_category_request_indicator",
10948
16
        FT_BOOLEAN, 16, TFS(&isup_calling_partys_category_request_ind_value), D_16BIT_MASK,
10949
16
        NULL, HFILL }},
10950
10951
16
    { &hf_isup_charge_information_request_indicator,
10952
16
      { "Charge information request indicator",  "isup.charge_information_request_indicator",
10953
16
        FT_BOOLEAN, 16, TFS(&isup_charge_information_request_ind_value), E_16BIT_MASK,
10954
16
        NULL, HFILL }},
10955
10956
16
    { &hf_isup_malicious_call_identification_request_indicator,
10957
16
      { "Malicious call identification request indicator (ISUP'88)",  "isup.malicious_call_ident_request_indicator",
10958
16
        FT_BOOLEAN, 16, TFS(&isup_malicious_call_identification_request_ind_value), H_16BIT_MASK,
10959
16
        NULL, HFILL }},
10960
10961
16
    { &hf_isup_calling_party_address_response_indicator,
10962
16
      { "Calling party address response indicator",  "isup.calling_party_address_response_indicator",
10963
16
        FT_UINT16, BASE_HEX, VALS(isup_calling_party_address_response_ind_value), BA_16BIT_MASK,
10964
16
        NULL, HFILL }},
10965
10966
16
    { &hf_isup_OECD_inf_ind,
10967
16
      { "OECD information indicator",  "isup.OECD_inf_ind_vals",
10968
16
        FT_UINT8, BASE_HEX, VALS(OECD_inf_ind_vals), BA_8BIT_MASK,
10969
16
        NULL, HFILL }},
10970
10971
16
    { &hf_isup_IECD_inf_ind,
10972
16
      { "IECD information indicator",  "isup.IECD_inf_ind_vals",
10973
16
        FT_UINT8, BASE_HEX, VALS(IECD_inf_ind_vals), DC_8BIT_MASK,
10974
16
        NULL, HFILL }},
10975
10976
16
    { &hf_isup_OECD_req_ind,
10977
16
      { "OECD request indicator",  "isup.OECD_req_ind_vals",
10978
16
        FT_UINT8, BASE_HEX, VALS(OECD_req_ind_vals), FE_8BIT_MASK,
10979
16
        NULL, HFILL }},
10980
10981
16
    { &hf_isup_IECD_req_ind,
10982
16
      { "IECD request indicator",  "isup.IECD_req_ind_vals",
10983
16
        FT_UINT8, BASE_HEX, VALS(IECD_req_ind_vals), HG_8BIT_MASK,
10984
16
        NULL, HFILL }},
10985
10986
16
    { &hf_isup_hold_provided_indicator,
10987
16
      { "Hold provided indicator",  "isup.hold_provided_indicator",
10988
16
        FT_BOOLEAN, 16, TFS(&isup_hold_provided_ind_value), C_16BIT_MASK,
10989
16
        NULL, HFILL }},
10990
10991
16
    { &hf_isup_calling_partys_category_response_indicator,
10992
16
      { "Calling party's category response indicator",  "isup.calling_partys_category_response_indicator",
10993
16
        FT_BOOLEAN, 16, TFS(&isup_calling_partys_category_response_ind_value), F_16BIT_MASK,
10994
16
        NULL, HFILL }},
10995
10996
16
    { &hf_isup_charge_information_response_indicator,
10997
16
      { "Charge information response indicator",  "isup.charge_information_response_indicator",
10998
16
        FT_BOOLEAN, 16, TFS(&isup_charge_information_response_ind_value), G_16BIT_MASK,
10999
16
        NULL, HFILL }},
11000
11001
16
    { &hf_isup_solicited_indicator,
11002
16
      { "Solicited indicator",  "isup.solicited_indicator",
11003
16
        FT_BOOLEAN, 16, TFS(&isup_solicited_information_ind_value), H_16BIT_MASK,
11004
16
        NULL, HFILL }},
11005
11006
16
    { &hf_isup_continuity_indicator,
11007
16
      { "Continuity indicator",  "isup.continuity_indicator",
11008
16
        FT_BOOLEAN, 8, TFS(&isup_continuity_ind_value), A_8BIT_MASK,
11009
16
        NULL, HFILL }},
11010
11011
16
    { &hf_isup_backw_call_charge_ind,
11012
16
      { "Charge indicator",  "isup.charge_indicator",
11013
16
        FT_UINT16, BASE_HEX, VALS(isup_charge_ind_value), BA_16BIT_MASK,
11014
16
        NULL, HFILL }},
11015
11016
16
    { &hf_isup_backw_call_called_partys_status_ind,
11017
16
      { "Called party's status indicator",  "isup.called_partys_status_indicator",
11018
16
        FT_UINT16, BASE_HEX, VALS(isup_called_partys_status_ind_value), DC_16BIT_MASK,
11019
16
        NULL, HFILL }},
11020
11021
16
    { &hf_isup_backw_call_called_partys_category_ind,
11022
16
      { "Called party's category indicator",  "isup.called_partys_category_indicator",
11023
16
        FT_UINT16, BASE_HEX, VALS(isup_called_partys_category_ind_value), FE_16BIT_MASK,
11024
16
        NULL, HFILL }},
11025
11026
16
    { &hf_isup_backw_call_end_to_end_method_ind,
11027
16
      { "End-to-end method indicator",  "isup.backw_call_end_to_end_method_indicator",
11028
16
        FT_UINT16, BASE_HEX, VALS(isup_end_to_end_method_ind_value), HG_16BIT_MASK,
11029
16
        NULL, HFILL }},
11030
11031
16
    { &hf_isup_backw_call_interworking_ind,
11032
16
      { "Interworking indicator",  "isup.backw_call_interworking_indicator",
11033
16
        FT_BOOLEAN, 16, TFS(&isup_interworking_ind_value), I_16BIT_MASK,
11034
16
        NULL, HFILL }},
11035
11036
16
    { &hf_isup_backw_call_end_to_end_info_ind,
11037
16
      { "End-to-end information indicator",  "isup.backw_call_end_to_end_information_indicator",
11038
16
        FT_BOOLEAN, 16, TFS(&isup_end_to_end_info_ind_value), J_16BIT_MASK,
11039
16
        NULL, HFILL }},
11040
11041
16
    { &hf_isup_backw_call_iam_seg_ind,
11042
16
      { "IAM segmentation indicator",  "isup.backw_call_iam_seg_ind",
11043
16
        FT_BOOLEAN, 16, TFS(&ansi_isup_iam_seg_ind_value), J_16BIT_MASK,
11044
16
        NULL, HFILL } },
11045
11046
16
    { &hf_isup_backw_call_isdn_user_part_ind,
11047
16
      { "ISDN user part indicator",  "isup.backw_call_isdn_user_part_indicator",
11048
16
        FT_BOOLEAN, 16, TFS(&isup_ISDN_user_part_ind_value), K_16BIT_MASK,
11049
16
        NULL, HFILL }},
11050
11051
16
    { &hf_isup_backw_call_holding_ind,
11052
16
      { "Holding indicator",  "isup.backw_call_holding_indicator",
11053
16
        FT_BOOLEAN, 16, TFS(&isup_holding_ind_value), L_16BIT_MASK,
11054
16
        NULL, HFILL }},
11055
11056
16
    { &hf_isup_backw_call_isdn_access_ind,
11057
16
      { "ISDN access indicator",  "isup.backw_call_isdn_access_indicator",
11058
16
        FT_BOOLEAN, 16, TFS(&isup_ISDN_terminating_access_ind_value), M_16BIT_MASK,
11059
16
        NULL, HFILL }},
11060
11061
16
    { &hf_isup_backw_call_echo_control_device_ind,
11062
16
      { "Echo Control Device Indicator",  "isup.backw_call_echo_control_device_indicator",
11063
16
        FT_BOOLEAN, 16, TFS(&isup_echo_control_device_ind_value), N_16BIT_MASK,
11064
16
        NULL, HFILL }},
11065
11066
16
    { &hf_isup_backw_call_sccp_method_ind,
11067
16
      { "SCCP method indicator",  "isup.backw_call_sccp_method_indicator",
11068
16
        FT_UINT16, BASE_HEX, VALS(isup_SCCP_method_ind_value), PO_16BIT_MASK,
11069
16
        NULL, HFILL }},
11070
11071
16
    { &hf_isup_cause_indicator,
11072
16
      { "Cause indicator",  "isup.cause_indicator",
11073
16
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &q850_cause_code_vals_ext, 0x7f,
11074
16
        NULL, HFILL }},
11075
11076
16
    { &hf_ansi_isup_cause_indicator,
11077
16
      { "Cause indicator",  "ansi_isup.cause_indicator",
11078
16
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &ansi_isup_cause_code_vals_ext, 0x7f,
11079
16
        NULL, HFILL }},
11080
11081
16
    { &hf_isup_suspend_resume_indicator,
11082
16
      { "Suspend/Resume indicator",  "isup.suspend_resume_indicator",
11083
16
        FT_BOOLEAN, 8, TFS(&isup_suspend_resume_ind_value), A_8BIT_MASK,
11084
16
        NULL, HFILL }},
11085
11086
16
    { &hf_isup_range_indicator,
11087
16
      { "Range indicator",  "isup.range_indicator",
11088
16
        FT_UINT8, BASE_DEC, NULL , 0x0,
11089
16
        NULL, HFILL }},
11090
11091
16
    { &hf_isup_bitbucket,
11092
16
      { "Bit",  "isup.bitbucket",
11093
16
        FT_UINT8, BASE_DEC, NULL , 0x0,
11094
16
        NULL, HFILL }},
11095
11096
16
    { &hf_isup_cgs_message_type,
11097
16
      { "Circuit group supervision message type",  "isup.cgs_message_type",
11098
16
        FT_UINT8, BASE_DEC, VALS(isup_cgs_message_type_value), BA_8BIT_MASK,
11099
16
        NULL, HFILL }},
11100
11101
16
    { &hf_isup_mtc_blocking_state1,
11102
16
      { "Maintenance blocking state",  "isup.mtc_blocking_state",
11103
16
        FT_UINT8, BASE_DEC, VALS(isup_mtc_blocking_state_DC00_value), BA_8BIT_MASK,
11104
16
        NULL, HFILL }},
11105
11106
16
    { &hf_isup_mtc_blocking_state2,
11107
16
      { "Maintenance blocking state",  "isup.mtc_blocking_state",
11108
16
        FT_UINT8, BASE_DEC, VALS(isup_mtc_blocking_state_DCnot00_value), BA_8BIT_MASK,
11109
16
        NULL, HFILL }},
11110
11111
16
    { &hf_isup_call_proc_state,
11112
16
      { "Call processing state",  "isup.call_processing_state",
11113
16
        FT_UINT8, BASE_DEC, VALS(isup_call_processing_state_value), DC_8BIT_MASK,
11114
16
        NULL, HFILL }},
11115
11116
16
    { &hf_isup_hw_blocking_state,
11117
16
      { "HW blocking state",  "isup.hw_blocking_state",
11118
16
        FT_UINT8, BASE_DEC, VALS(isup_HW_blocking_state_value), FE_8BIT_MASK,
11119
16
        NULL, HFILL }},
11120
11121
16
    { &hf_isup_event_ind,
11122
16
      { "Event indicator",  "isup.event_ind",
11123
16
        FT_UINT8, BASE_DEC, VALS(isup_event_ind_value), GFEDCBA_8BIT_MASK,
11124
16
        NULL, HFILL }},
11125
11126
16
    { &hf_isup_event_presentation_restricted_ind,
11127
16
      { "Event presentation restricted indicator",  "isup.event_presentation_restr_ind",
11128
16
        FT_BOOLEAN, 8, TFS(&isup_event_presentation_restricted_ind_value), H_8BIT_MASK,
11129
16
        NULL, HFILL }},
11130
11131
16
    { &hf_isup_cug_call_ind,
11132
16
      { "Closed user group call indicator",  "isup.clg_call_ind",
11133
16
        FT_UINT8, BASE_DEC, VALS(isup_CUG_call_ind_value), BA_8BIT_MASK,
11134
16
        NULL, HFILL }},
11135
11136
16
    { &hf_isup_simple_segmentation_ind,
11137
16
      { "Simple segmentation indicator",  "isup.simple_segmentation_ind",
11138
16
        FT_BOOLEAN, 8, TFS(&isup_simple_segmentation_ind_value), C_8BIT_MASK,
11139
16
        NULL, HFILL }},
11140
11141
16
    { &hf_isup_connected_line_identity_request_ind,
11142
16
      { "Connected line identity request indicator",  "isup.connected_line_identity_request_ind",
11143
16
        FT_BOOLEAN, 8, TFS(&tfs_requested_not_requested), H_8BIT_MASK,
11144
16
        NULL, HFILL }},
11145
11146
16
    { &hf_isup_redirecting_ind,
11147
16
      { "Redirection indicator",  "isup.redirecting_ind",
11148
16
        FT_UINT16, BASE_DEC, VALS(isup_redirecting_ind_value), CBA_16BIT_MASK,
11149
16
        NULL, HFILL }},
11150
11151
16
    { &hf_isup_original_redirection_reason,
11152
16
      { "Original redirection reason",  "isup.original_redirection_reason",
11153
16
        FT_UINT16, BASE_DEC, VALS(isup_original_redirection_reason_value), HGFE_16BIT_MASK,
11154
16
        NULL, HFILL }},
11155
11156
16
    { &hf_isup_redirection_counter,
11157
16
      { "Redirection counter",  "isup.redirection_counter",
11158
16
        FT_UINT16, BASE_DEC, NULL, KJI_16BIT_MASK,
11159
16
        NULL, HFILL }},
11160
11161
16
    { &hf_isup_redirection_reason,
11162
16
      { "Redirection reason",  "isup.redirection_reason",
11163
16
        FT_UINT16, BASE_DEC, VALS(isup_redirection_reason_value), PONM_16BIT_MASK,
11164
16
        NULL, HFILL }},
11165
11166
16
    { &hf_isup_type_of_network_identification,
11167
16
      { "Type of network identification",  "isup.type_of_network_identification",
11168
16
        FT_UINT8, BASE_DEC, VALS(isup_type_of_network_identification_value), GFE_8BIT_MASK,
11169
16
        NULL, HFILL }},
11170
11171
16
    { &hf_isup_network_identification_plan,
11172
16
      { "Network identification plan",  "isup.network_identification_plan",
11173
16
        FT_UINT8, BASE_DEC, VALS(isup_network_identification_plan_value), DCBA_8BIT_MASK,
11174
16
        NULL, HFILL }},
11175
11176
16
    { &hf_isup_map_type,
11177
16
      { "Map Type",  "isup.map_type",
11178
16
        FT_UINT8, BASE_DEC, VALS(isup_map_type_value), FEDCBA_8BIT_MASK,
11179
16
        NULL, HFILL }},
11180
11181
16
    { &hf_isup_automatic_congestion_level,
11182
16
      { "Automatic congestion level",  "isup.automatic_congestion_level",
11183
16
        FT_UINT8, BASE_DEC, VALS(isup_auto_congestion_level_value), 0x0,
11184
16
        NULL, HFILL }},
11185
11186
16
    { &hf_isup_inband_information_ind,
11187
16
      { "In-band information indicator",  "isup.inband_information_ind",
11188
16
        FT_BOOLEAN, 8, TFS(&isup_inband_information_ind_value), A_8BIT_MASK,
11189
16
        NULL, HFILL }},
11190
11191
16
    { &hf_isup_call_diversion_may_occur_ind,
11192
16
      { "Call diversion may occur indicator",  "isup.call_diversion_may_occur_ind",
11193
16
        FT_BOOLEAN, 8, TFS(&isup_call_diversion_may_occur_ind_value), B_8BIT_MASK,
11194
16
        NULL, HFILL }},
11195
11196
16
    { &hf_isup_mlpp_user_ind,
11197
16
      { "MLPP user indicator",  "isup.mlpp_user",
11198
16
        FT_BOOLEAN, 8, TFS(&isup_MLPP_user_ind_value), D_8BIT_MASK,
11199
16
        NULL, HFILL }},
11200
11201
16
    { &hf_isup_UUI_type,
11202
16
      { "User-to-User indicator type",  "isup.UUI_type",
11203
16
        FT_BOOLEAN, 8, TFS(&tfs_response_request), A_8BIT_MASK,
11204
16
        NULL, HFILL }},
11205
11206
16
    { &hf_isup_UUI_req_service1,
11207
16
      { "User-to-User indicator request service 1",  "isup.UUI_req_service1",
11208
16
        FT_UINT8, BASE_DEC, VALS(isup_UUI_request_service_values), CB_8BIT_MASK,
11209
16
        NULL, HFILL }},
11210
11211
16
    { &hf_isup_UUI_req_service2,
11212
16
      { "User-to-User indicator request service 2",  "isup.UUI_req_service2",
11213
16
        FT_UINT8, BASE_DEC, VALS(isup_UUI_request_service_values), ED_8BIT_MASK,
11214
16
        NULL, HFILL }},
11215
11216
16
    { &hf_isup_UUI_req_service3,
11217
16
      { "User-to-User indicator request service 3",  "isup.UUI_req_service3",
11218
16
        FT_UINT8, BASE_DEC, VALS(isup_UUI_request_service_values), GF_8BIT_MASK,
11219
16
        NULL, HFILL }},
11220
11221
16
    { &hf_isup_UUI_res_service1,
11222
16
      { "User-to-User indicator response service 1",  "isup.UUI_res_service1",
11223
16
        FT_UINT8, BASE_DEC, VALS(isup_UUI_response_service_values), CB_8BIT_MASK,
11224
16
        NULL, HFILL }},
11225
11226
16
    { &hf_isup_UUI_res_service2,
11227
16
      { "User-to-User indicator response service 2",  "isup.UUI_res_service2",
11228
16
        FT_UINT8, BASE_DEC, VALS(isup_UUI_response_service_values), ED_8BIT_MASK,
11229
16
        NULL, HFILL }},
11230
11231
16
    { &hf_isup_UUI_res_service3,
11232
16
      { "User-to-User response service 3",  "isup.UUI_res_service3",
11233
16
        FT_UINT8, BASE_DEC, VALS(isup_UUI_response_service_values), GF_8BIT_MASK,
11234
16
        NULL, HFILL }},
11235
11236
16
    { &hf_isup_notification_indicator,
11237
16
      { "Notification indicator",  "isup.notification_indicator",
11238
16
        FT_UINT8, BASE_DEC | BASE_EXT_STRING, &q763_generic_notification_indicator_vals_ext, 0x7f,
11239
16
        NULL, HFILL }},
11240
11241
16
    { &hf_isup_UUI_network_discard_ind,
11242
16
      { "User-to-User indicator network discard indicator",  "isup.UUI_network_discard_ind",
11243
16
        FT_BOOLEAN, 8, TFS(&isup_UUI_network_discard_ind_value), H_8BIT_MASK,
11244
16
        NULL, HFILL }},
11245
11246
16
    { &hf_isup_access_delivery_ind,
11247
16
      { "Access delivery indicator",  "isup.access_delivery_ind",
11248
16
        FT_BOOLEAN, 8, TFS(&isup_access_delivery_ind_value), A_8BIT_MASK,
11249
16
        NULL, HFILL }},
11250
11251
16
    { &hf_isup_transmission_medium_requirement_prime,
11252
16
      { "Transmission medium requirement prime",  "isup.transmission_medium_requirement_prime",
11253
16
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &isup_transmission_medium_requirement_prime_value_ext, 0x0,
11254
16
        NULL, HFILL }},
11255
11256
16
    { &hf_isup_loop_prevention_response_ind,
11257
16
      { "Response indicator",  "isup.loop_prevention_response_ind",
11258
16
        FT_UINT8, BASE_DEC, VALS(isup_loop_prevention_response_ind_value), CB_8BIT_MASK,
11259
16
        NULL, HFILL }},
11260
11261
16
    { &hf_isup_temporary_alternative_routing_ind,
11262
16
      { "Temporary alternative routing indicator",  "isup.temporary_alternative_routing_ind",
11263
16
        FT_BOOLEAN, 8, TFS(&isup_temporary_alternative_routing_ind_value), A_8BIT_MASK,
11264
16
        NULL, HFILL }},
11265
11266
16
    { &hf_isup_extension_ind,
11267
16
      { "Extension indicator",  "isup.extension_ind",
11268
16
        FT_BOOLEAN, 8, TFS(&isup_extension_ind_value), H_8BIT_MASK,
11269
16
        NULL, HFILL }},
11270
11271
16
    { &hf_isup_call_to_be_diverted_ind,
11272
16
      { "Call to be diverted indicator",  "isup.call_to_be_diverted_ind",
11273
16
        FT_UINT8, BASE_DEC, VALS(isup_call_to_be_diverted_ind_value), BA_8BIT_MASK,
11274
16
        NULL, HFILL }},
11275
11276
16
    { &hf_isup_call_to_be_offered_ind,
11277
16
      { "Call to be offered indicator",  "isup.call_to_be_offered_ind",
11278
16
        FT_UINT8, BASE_DEC, VALS(isup_call_to_be_offered_ind_value), BA_8BIT_MASK,
11279
16
        NULL, HFILL }},
11280
11281
16
    { &hf_isup_conference_acceptance_ind,
11282
16
      { "Conference acceptance indicator",  "isup.conference_acceptance_ind",
11283
16
        FT_UINT8, BASE_DEC, VALS(isup_conference_acceptance_ind_value), BA_8BIT_MASK,
11284
16
        NULL, HFILL }},
11285
11286
16
    { &hf_isup_transit_at_intermediate_exchange_ind,
11287
16
      { "Transit at intermediate exchange indicator", "isup.transit_at_intermediate_exchange_ind",
11288
16
        FT_BOOLEAN, 8, TFS(&isup_transit_at_intermediate_exchange_ind_value), A_8BIT_MASK,
11289
16
        NULL, HFILL }},
11290
11291
16
    { &hf_isup_Release_call_ind,
11292
16
      { "Release call indicator", "isup.Release_call_ind",
11293
16
        FT_BOOLEAN, 8, TFS(&isup_Release_call_indicator_value), B_8BIT_MASK,
11294
16
        NULL, HFILL }},
11295
11296
16
    { &hf_isup_Send_notification_ind,
11297
16
      { "Send notification indicator", "isup.Send_notification_ind",
11298
16
        FT_BOOLEAN, 8, TFS(&isup_Send_notification_ind_value), C_8BIT_MASK,
11299
16
        NULL, HFILL }},
11300
11301
16
    { &hf_isup_Discard_message_ind_value,
11302
16
      { "Discard message indicator", "isup.Discard_message_ind_value",
11303
16
        FT_BOOLEAN, 8, TFS(&isup_Discard_message_ind_value), D_8BIT_MASK,
11304
16
        NULL, HFILL }},
11305
11306
16
    { &hf_isup_Discard_parameter_ind,
11307
16
      { "Discard parameter indicator", "isup.Discard_parameter_ind",
11308
16
        FT_BOOLEAN, 8, TFS(&isup_Discard_parameter_ind_value), E_8BIT_MASK,
11309
16
        NULL, HFILL }},
11310
11311
16
    { &hf_isup_Pass_on_not_possible_indicator,
11312
16
      { "Pass on not possible indicator",  "isup.Pass_on_not_possible_ind",
11313
16
        FT_UINT8, BASE_HEX, VALS(isup_Pass_on_not_possible_indicator_vals), GF_8BIT_MASK,
11314
16
        NULL, HFILL }},
11315
11316
16
    { &hf_isup_pass_on_not_possible_indicator2,
11317
16
      { "Pass on not possible indicator",  "isup.Pass_on_not_possible_val",
11318
16
        FT_BOOLEAN, 8, TFS(&isup_pass_on_not_possible_indicator_value), E_8BIT_MASK,
11319
16
        NULL, HFILL }},
11320
11321
16
    { &hf_isup_Broadband_narrowband_interworking_ind,
11322
16
      { "Broadband narrowband interworking indicator Bits JF",  "isup.broadband_narrowband_interworking_ind",
11323
16
        FT_UINT8, BASE_HEX, VALS(ISUP_Broadband_narrowband_interworking_indicator_vals), BA_8BIT_MASK,
11324
16
        NULL, HFILL }},
11325
11326
16
    { &hf_isup_Broadband_narrowband_interworking_ind2,
11327
16
      { "Broadband narrowband interworking indicator Bits GF",  "isup.broadband_narrowband_interworking_ind2",
11328
16
        FT_UINT8, BASE_HEX, VALS(ISUP_Broadband_narrowband_interworking_indicator_vals), GF_8BIT_MASK,
11329
16
        NULL, HFILL }},
11330
11331
16
    { &hf_isup_app_cont_ident,
11332
16
      { "Application context identifier",  "isup.app_context_identifier",
11333
16
        FT_UINT16, BASE_DEC, VALS(isup_application_transport_parameter_value), GFEDCBA_8BIT_MASK,
11334
16
        NULL, HFILL }},
11335
11336
16
    { &hf_isup_app_Release_call_ind,
11337
16
      { "Release call indicator (RCI)",  "isup.app_Release_call_indicator",
11338
16
        FT_BOOLEAN, 8, TFS(&isup_Release_call_indicator_value), A_8BIT_MASK,
11339
16
        NULL, HFILL }},
11340
11341
16
    { &hf_isup_app_Send_notification_ind,
11342
16
      { "Send notification indicator (SNI)",  "isup.app_Send_notification_ind",
11343
16
        FT_BOOLEAN, 8, TFS(&isup_Send_notification_ind_value), B_8BIT_MASK,
11344
16
        NULL, HFILL }},
11345
11346
16
    { &hf_isup_apm_segmentation_ind,
11347
16
      { "APM segmentation indicator",  "isup.apm_segmentation_ind",
11348
16
        FT_UINT8, BASE_DEC, VALS(isup_APM_segmentation_ind_value), FEDCBA_8BIT_MASK,
11349
16
        NULL, HFILL }},
11350
11351
16
    { &hf_isup_apm_si_ind,
11352
16
      { "Sequence indicator (SI)",  "isup.APM_Sequence_ind",
11353
16
        FT_BOOLEAN, 8, TFS(&isup_Sequence_ind_value), G_8BIT_MASK,
11354
16
        NULL, HFILL }},
11355
11356
16
    { &hf_isup_orig_addr_len,
11357
16
      { "Originating Address length",  "isup.orig_addr_len",
11358
16
        FT_UINT8, BASE_DEC, NULL, 0x0,
11359
16
        NULL, HFILL }},
11360
11361
16
    { &hf_isup_dest_addr_len,
11362
16
      { "Destination Address length",  "isup.dest_addr_len",
11363
16
        FT_UINT8, BASE_DEC, NULL, 0x0,
11364
16
        NULL, HFILL }},
11365
11366
16
    { &hf_isup_apm_slr,
11367
16
      { "Segmentation local reference (SLR)",  "isup.APM_slr",
11368
16
        FT_UINT8, BASE_DEC, NULL, GFEDCBA_8BIT_MASK,
11369
16
        NULL, HFILL }},
11370
16
    { &hf_isup_cause_location,
11371
16
      { "Cause location", "isup.cause_location",
11372
16
        FT_UINT8, BASE_DEC|BASE_EXT_STRING, &q931_cause_location_vals_ext, 0x0f,
11373
16
        NULL, HFILL }},
11374
11375
16
    { &hf_ansi_isup_coding_standard,
11376
16
      { "Coding standard", "ansi_isup.coding_standard",
11377
16
        FT_UINT8, BASE_HEX, VALS(ansi_isup_coding_standard_vals), 0x60,
11378
16
        NULL, HFILL }},
11379
16
    { &hf_ansi_isup_spare_b7,
11380
16
      { "Spare", "ansi_isup.spare.b7",
11381
16
      FT_UINT8, BASE_DEC, NULL, 0x80,
11382
16
      NULL, HFILL }},
11383
16
    { &hf_ansi_isup_type_of_nw_id,
11384
16
      { "Type of network identification", "ansi_isup.type_of_nw_id",
11385
16
        FT_UINT8, BASE_DEC, VALS(ansi_isup_type_of_nw_id_vals), 0x70,
11386
16
        NULL, HFILL } },
11387
16
    { &hf_ansi_isup_nw_id_plan,
11388
16
      { "Network identification plan", "ansi_isup.nw_id_plan",
11389
16
        FT_UINT8, BASE_DEC, VALS(ansi_isup_nw_id_plan_vals), 0x0f,
11390
16
        NULL, HFILL } },
11391
16
    { &hf_ansi_isup_tns_nw_id_plan,
11392
16
      { "Network identification plan", "ansi_isup.tns.nw_id_plan",
11393
16
        FT_UINT8, BASE_DEC, VALS(ansi_isup_tns_nw_id_plan_vals), 0x0f,
11394
16
        NULL, HFILL } },
11395
16
    { &hf_ansi_isup_nw_id,
11396
16
      { "Network id",  "ansi_isup.nw_id",
11397
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11398
16
        NULL, HFILL } },
11399
16
    { &hf_ansi_isup_circuit_code,
11400
16
      { "Circuit code", "ansi_isup.circuit_code",
11401
16
        FT_UINT8, BASE_DEC, NULL, 0xf0,
11402
16
        NULL, HFILL } },
11403
11404
16
      { &hf_bat_ase_identifier,
11405
16
      { "BAT ASE Identifiers",  "bicc.bat_ase_identifier",
11406
16
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &bat_ase_list_of_Identifiers_vals_ext, 0x0,
11407
16
        NULL, HFILL }},
11408
11409
16
    { &hf_length_indicator,
11410
16
      { "BAT ASE Element length indicator",  "bicc.bat_ase_length_indicator",
11411
16
        FT_UINT16, BASE_DEC, NULL, 0x0,
11412
16
        NULL, HFILL }},
11413
11414
16
    { &hf_Action_Indicator,
11415
16
      { "BAT ASE action indicator field",  "bicc.bat_ase_bat_ase_action_indicator_field",
11416
16
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &bat_ase_action_indicator_field_vals_ext, 0x00,
11417
16
        NULL, HFILL }},
11418
11419
16
    { &hf_Instruction_ind_for_general_action,
11420
16
      { "BAT ASE Instruction indicator for general action",  "bicc.bat_ase_Instruction_ind_for_general_action",
11421
16
        FT_UINT8, BASE_HEX, VALS(Instruction_indicator_for_general_action_vals), 0x03,
11422
16
        NULL, HFILL }},
11423
11424
16
    { &hf_Send_notification_ind_for_general_action,
11425
16
      { "Send notification indicator for general action",  "bicc.bat_ase_Send_notification_ind_for_general_action",
11426
16
        FT_BOOLEAN, 8, TFS(&isup_Send_notification_ind_value), 0x04,
11427
16
        NULL, HFILL }},
11428
11429
16
    { &hf_Instruction_ind_for_pass_on_not_possible,
11430
16
      { "Instruction ind for pass-on not possible",  "bicc.bat_ase_Instruction_ind_for_pass_on_not_possible",
11431
16
        FT_UINT8, BASE_HEX, VALS(Instruction_indicator_for_pass_on_not_possible_vals), 0x30,
11432
16
        NULL, HFILL }},
11433
11434
16
    { &hf_Send_notification_ind_for_pass_on_not_possible,
11435
16
      { "Send notification indication for pass-on not possible",  "bicc.bat_ase_Send_notification_ind_for_pass_on_not_possible",
11436
16
        FT_BOOLEAN, 8, TFS(&isup_Send_notification_ind_value), 0x40,
11437
16
        NULL, HFILL }},
11438
11439
16
    { &hf_BCTP_Version_Indicator,
11440
16
      { "BCTP Version Indicator",  "bicc.bat_ase_BCTP_Version_Indicator",
11441
16
        FT_UINT8, BASE_DEC, NULL, 0x1f,
11442
16
        NULL, HFILL }},
11443
11444
16
    { &hf_BVEI,
11445
16
      { "BVEI",  "bicc.bat_ase_BCTP_BVEI",
11446
16
        FT_BOOLEAN, 8, TFS(&BCTP_BVEI_value), 0x40,
11447
16
        NULL, HFILL }},
11448
11449
16
    { &hf_Tunnelled_Protocol_Indicator,
11450
16
      { "Tunnelled Protocol Indicator",  "bicc.bat_ase_BCTP_Tunnelled_Protocol_Indicator",
11451
16
        FT_UINT8, BASE_DEC, VALS(BCTP_Tunnelled_Protocol_Indicator_vals), 0x3f,
11452
16
        NULL, HFILL }},
11453
11454
16
    { &hf_TPEI,
11455
16
      { "TPEI",  "bicc.bat_ase_BCTP_tpei",
11456
16
        FT_BOOLEAN, 8, TFS(&BCTP_TPEI_value), 0x40,
11457
16
        NULL, HFILL }},
11458
11459
16
    { &hf_bncid,
11460
16
      { "Backbone Network Connection Identifier (BNCId)", "bat_ase.bncid",
11461
16
        FT_UINT32, BASE_HEX, NULL, 0x0,
11462
16
        NULL, HFILL }},
11463
11464
16
    { &hf_bat_ase_biwfa,
11465
16
      { "Interworking Function Address(X.213 NSAP encoded)", "bat_ase.biwfa",
11466
16
        FT_BYTES, BASE_NONE, NULL, 0x0,
11467
16
        NULL, HFILL }},
11468
11469
16
    { &hf_afi,
11470
16
      { "X.213 Address Format Information (AFI)",  "x213.afi",
11471
16
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &x213_afi_value_ext, 0x0,
11472
16
        NULL, HFILL }},
11473
11474
16
    { &hf_bicc_nsap_dsp,
11475
16
      { "X.213 Address Format Information (DSP)",  "x213.dsp",
11476
16
        FT_BYTES, BASE_NONE, NULL, 0x0,
11477
16
        NULL, HFILL }},
11478
11479
16
    { &hf_bicc_nsap_dsp_length,
11480
16
      { "DSP Length",  "x213.dsp_length",
11481
16
        FT_UINT32, BASE_DEC, NULL, 0x0,
11482
16
        NULL, HFILL }},
11483
11484
16
    { &hf_characteristics,
11485
16
      { "Backbone network connection characteristics", "bat_ase.char",
11486
16
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &bearer_network_connection_characteristics_vals_ext, 0x0,
11487
16
        NULL, HFILL }},
11488
11489
16
    { &hf_Organization_Identifier,
11490
16
      { "Organization identifier subfield",  "bat_ase.organization_identifier_subfield",
11491
16
        FT_UINT8, BASE_DEC, VALS(bat_ase_organization_identifier_subfield_vals), 0x0,
11492
16
        NULL, HFILL }},
11493
11494
16
    { &hf_codec_type,
11495
16
      { "ITU-T codec type subfield",  "bat_ase.ITU_T_codec_type_subfield",
11496
16
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &ITU_T_codec_type_subfield_vals_ext, 0x0,
11497
16
        NULL, HFILL }},
11498
11499
16
    { &hf_etsi_codec_type,
11500
16
      { "ETSI codec type subfield",  "bat_ase.ETSI_codec_type_subfield",
11501
16
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &ETSI_codec_type_subfield_vals_ext, 0x0,
11502
16
        NULL, HFILL }},
11503
11504
16
    { &hf_active_code_set,
11505
16
      { "Active Code Set",  "bat_ase.acs",
11506
16
        FT_UINT8, BASE_HEX, NULL, 0x0,
11507
16
        NULL, HFILL }},
11508
11509
16
    { &hf_active_code_set_12_2,
11510
16
      { "12.2 kbps rate",  "bat_ase.acs.12_2",
11511
16
        FT_UINT8, BASE_HEX, NULL, 0x80,
11512
16
        NULL, HFILL }},
11513
11514
16
    { &hf_active_code_set_10_2,
11515
16
      { "10.2 kbps rate",  "bat_ase.acs.10_2",
11516
16
        FT_UINT8, BASE_HEX, NULL, 0x40,
11517
16
        NULL, HFILL }},
11518
11519
16
    { &hf_active_code_set_7_95,
11520
16
      { "7.95 kbps rate",  "bat_ase.acs.7_95",
11521
16
        FT_UINT8, BASE_HEX, NULL, 0x20,
11522
16
        NULL, HFILL }},
11523
11524
16
    { &hf_active_code_set_7_40,
11525
16
      { "7.40 kbps rate",  "bat_ase.acs.7_40",
11526
16
        FT_UINT8, BASE_HEX, NULL, 0x10,
11527
16
        NULL, HFILL }},
11528
11529
16
    { &hf_active_code_set_6_70,
11530
16
      { "6.70 kbps rate",  "bat_ase.acs.6_70",
11531
16
        FT_UINT8, BASE_HEX, NULL, 0x08,
11532
16
        NULL, HFILL }},
11533
11534
16
    { &hf_active_code_set_5_90,
11535
16
      { "5.90 kbps rate",  "bat_ase.acs.5_90",
11536
16
        FT_UINT8, BASE_HEX, NULL, 0x04,
11537
16
        NULL, HFILL }},
11538
11539
16
    { &hf_active_code_set_5_15,
11540
16
      { "5.15 kbps rate",  "bat_ase.acs.5_15",
11541
16
        FT_UINT8, BASE_HEX, NULL, 0x02,
11542
16
        NULL, HFILL }},
11543
11544
16
    { &hf_active_code_set_4_75,
11545
16
      { "4.75 kbps rate",  "bat_ase.acs.4_75",
11546
16
        FT_UINT8, BASE_HEX, NULL, 0x01,
11547
16
        NULL, HFILL }},
11548
11549
16
    { &hf_supported_code_set,
11550
16
      { "Supported Code Set",  "bat_ase.scs",
11551
16
        FT_UINT8, BASE_HEX, NULL, 0x0,
11552
16
        NULL, HFILL }},
11553
11554
16
    { &hf_supported_code_set_12_2,
11555
16
      { "12.2 kbps rate",  "bat_ase.scs.12_2",
11556
16
        FT_UINT8, BASE_HEX, NULL, 0x80,
11557
16
        NULL, HFILL }},
11558
11559
16
    { &hf_supported_code_set_10_2,
11560
16
      { "10.2 kbps rate",  "bat_ase.scs.10_2",
11561
16
        FT_UINT8, BASE_HEX, NULL, 0x40,
11562
16
        NULL, HFILL }},
11563
11564
16
    { &hf_supported_code_set_7_95,
11565
16
      { "7.95 kbps rate",  "bat_ase.scs.7_95",
11566
16
        FT_UINT8, BASE_HEX, NULL, 0x20,
11567
16
        NULL, HFILL }},
11568
11569
16
    { &hf_supported_code_set_7_40,
11570
16
      { "7.40 kbps rate",  "bat_ase.scs.7_40",
11571
16
        FT_UINT8, BASE_HEX, NULL, 0x10,
11572
16
        NULL, HFILL }},
11573
11574
16
    { &hf_supported_code_set_6_70,
11575
16
      { "6.70 kbps rate",  "bat_ase.scs.6_70",
11576
16
        FT_UINT8, BASE_HEX, NULL, 0x08,
11577
16
        NULL, HFILL }},
11578
11579
16
    { &hf_supported_code_set_5_90,
11580
16
      { "5.90 kbps rate",  "bat_ase.scs.5_90",
11581
16
        FT_UINT8, BASE_HEX, NULL, 0x04,
11582
16
        NULL, HFILL }},
11583
11584
16
    { &hf_supported_code_set_5_15,
11585
16
      { "5.15 kbps rate",  "bat_ase.scs.5_15",
11586
16
        FT_UINT8, BASE_HEX, NULL, 0x02,
11587
16
        NULL, HFILL }},
11588
11589
16
    { &hf_supported_code_set_4_75,
11590
16
      { "4.75 kbps rate",  "bat_ase.scs.4_75",
11591
16
        FT_UINT8, BASE_HEX, NULL, 0x01,
11592
16
        NULL, HFILL }},
11593
11594
16
    { &hf_optimisation_mode,
11595
16
      { "Optimisation Mode for ACS , OM",  "bat_ase.optimisation_mode",
11596
16
        FT_UINT8, BASE_HEX, VALS(optimisation_mode_vals), 0x8,
11597
16
        NULL, HFILL }},
11598
11599
16
    { &hf_max_codec_modes,
11600
16
      { "Maximal number of Codec Modes, MACS",  "bat_ase.macs",
11601
16
        FT_UINT8, BASE_DEC, NULL, 0x07,
11602
16
        NULL, HFILL }},
11603
11604
11605
16
    { &hf_bearer_control_tunneling,
11606
16
      { "Bearer control tunneling",  "bat_ase.bearer_control_tunneling",
11607
16
        FT_BOOLEAN, 8, TFS(&Bearer_Control_Tunnelling_ind_value), 0x01,
11608
16
        NULL, HFILL }},
11609
11610
16
    { &hf_BAT_ASE_Comp_Report_Reason,
11611
16
      { "Compatibility report reason",  "bat_ase.Comp_Report_Reason",
11612
16
        FT_UINT8, BASE_HEX, VALS(BAT_ASE_Report_Reason_vals), 0x0,
11613
16
        NULL, HFILL }},
11614
11615
11616
16
    { &hf_BAT_ASE_Comp_Report_ident,
11617
16
      { "Compatibility report ident",  "bat_ase.Comp_Report_ident",
11618
16
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &bat_ase_list_of_Identifiers_vals_ext, 0x0,
11619
16
        NULL, HFILL }},
11620
11621
16
    { &hf_BAT_ASE_Comp_Report_diagnostic,
11622
16
      { "Diagnostics",  "bat_ase.Comp_Report_diagnostic",
11623
16
        FT_UINT16, BASE_HEX, NULL, 0x0,
11624
16
        NULL, HFILL }},
11625
11626
16
    { &hf_Local_BCU_ID,
11627
16
      { "Local BCU ID",  "bat_ase.Local_BCU_ID",
11628
16
        FT_UINT32, BASE_HEX, NULL, 0x0,
11629
16
        NULL, HFILL }},
11630
11631
16
    { &hf_late_cut_through_cap_ind,
11632
16
      { "Late Cut-through capability indicator",  "bat_ase.late_cut_through_cap_ind",
11633
16
        FT_BOOLEAN, 8, TFS(&late_cut_through_cap_ind_value), 0x01,
11634
16
        NULL, HFILL }},
11635
11636
16
    { &hf_bat_ase_signal,
11637
16
      { "Q.765.5 - Signal Type",  "bat_ase.signal_type",
11638
16
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &BAT_ASE_Signal_Type_vals_ext, 0x0,
11639
16
        NULL, HFILL }},
11640
11641
16
    { &hf_bat_ase_duration,
11642
16
      { "Duration in ms",  "bat_ase.duration",
11643
16
        FT_UINT16, BASE_DEC, NULL, 0x0,
11644
16
        NULL, HFILL }},
11645
11646
16
    { &hf_bat_ase_default,
11647
16
      { "Default",  "bat_ase.default",
11648
16
        FT_BYTES, BASE_NONE, NULL, 0x0,
11649
16
        NULL, HFILL }},
11650
11651
16
    { &hf_bat_ase_bearer_redir_ind,
11652
16
      { "Redirection Indicator",  "bat_ase.bearer_redir_ind",
11653
16
        FT_UINT8, BASE_HEX|BASE_EXT_STRING, &Bearer_Redirection_Indicator_vals_ext, 0x0,
11654
16
        NULL, HFILL }},
11655
11656
16
    { &hf_nsap_ipv4_addr,
11657
16
      { "IWFA IPv4 Address", "nsap.ipv4_addr",
11658
16
        FT_IPv4, BASE_NONE, NULL, 0x0,
11659
16
        NULL, HFILL }},
11660
11661
16
    { &hf_nsap_ipv6_addr,
11662
16
      { "IWFA IPv6 Address", "nsap.ipv6_addr",
11663
16
        FT_IPv6, BASE_NONE, NULL, 0x0,
11664
16
        NULL, HFILL}},
11665
11666
16
    { &hf_iana_icp,
11667
16
      { "IANA ICP",  "nsap.iana_icp",
11668
16
        FT_UINT16, BASE_HEX, VALS(iana_icp_values), 0x0,
11669
16
        NULL, HFILL }},
11670
11671
16
    { &hf_isup_called,
11672
16
      { "Called Party Number",  "isup.called",
11673
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11674
16
        NULL, HFILL }},
11675
11676
16
    { &hf_isup_calling,
11677
16
      { "Calling Party Number",  "isup.calling",
11678
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11679
16
        NULL, HFILL }},
11680
11681
16
    { &hf_isup_redirecting,
11682
16
      { "Redirecting Number",  "isup.redirecting",
11683
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11684
16
        NULL, HFILL }},
11685
11686
16
    { &hf_isup_redirection_number,
11687
16
      { "Redirection Number",  "isup.redirection_number",
11688
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11689
16
        NULL, HFILL }},
11690
11691
16
    { &hf_isup_subsequent_number,
11692
16
      { "Subsequent Number",  "isup.subsequent_number",
11693
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11694
16
        NULL, HFILL }},
11695
11696
16
    { &hf_isup_connected_number,
11697
16
      { "Connected Number",  "isup.connected_number",
11698
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11699
16
        NULL, HFILL }},
11700
11701
16
    { &hf_isup_transit_network_selection,
11702
16
      { "Transit Network Selection",  "isup.transit_network_selection",
11703
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11704
16
        NULL, HFILL }},
11705
11706
16
    { &hf_isup_original_called_number,
11707
16
      { "Original Called Number",  "isup.original_called_number",
11708
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11709
16
        NULL, HFILL }},
11710
11711
16
    { &hf_isup_location_number,
11712
16
      { "Location Number",  "isup.location_number",
11713
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11714
16
        NULL, HFILL }},
11715
11716
16
    { &hf_isup_call_transfer_number,
11717
16
      { "Call Transfer Number",  "isup.call_transfer_number",
11718
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11719
16
        NULL, HFILL }},
11720
11721
16
    { &hf_isup_called_in_number,
11722
16
      { "Called IN Number",  "isup.called_in_number",
11723
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11724
16
        NULL, HFILL }},
11725
11726
16
    { &hf_isup_generic_number,
11727
16
      { "Generic Number",  "isup.generic_number",
11728
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11729
16
        NULL, HFILL }},
11730
11731
16
    { &hf_isup_jurisdiction,
11732
16
      { "Jurisdiction",  "isup.jurisdiction",
11733
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11734
16
        NULL, HFILL }},
11735
11736
16
    { &hf_isup_charge_number,
11737
16
      { "Charge Number",  "isup.charge_number",
11738
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11739
16
        NULL, HFILL }},
11740
11741
16
    { &hf_isup_apm_msg_fragments,
11742
16
     { "Message fragments", "isup.apm.msg.fragments",
11743
16
      FT_NONE, BASE_NONE, NULL, 0x00,
11744
16
      NULL, HFILL }},
11745
11746
16
    { &hf_isup_apm_msg_fragment,
11747
16
      { "Message fragment", "isup.apm.msg.fragment",
11748
16
        FT_FRAMENUM, BASE_NONE, NULL, 0x00,
11749
16
        NULL, HFILL }},
11750
11751
16
    { &hf_isup_apm_msg_fragment_overlap,
11752
16
      { "Message fragment overlap", "isup.apm.msg.fragment.overlap",
11753
16
        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
11754
16
        NULL, HFILL }},
11755
11756
16
    { &hf_isup_apm_msg_fragment_overlap_conflicts,
11757
16
      { "Message fragment overlapping with conflicting data", "isup.apm.msg.fragment.overlap.conflicts",
11758
16
        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
11759
16
        NULL, HFILL }},
11760
11761
16
    { &hf_isup_apm_msg_fragment_multiple_tails,
11762
16
      { "Message has multiple tail fragments", "isup.apm.msg.fragment.multiple_tails",
11763
16
        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
11764
16
        NULL, HFILL }},
11765
11766
16
    { &hf_isup_apm_msg_fragment_too_long_fragment,
11767
16
      { "Message fragment too long", "isup.apm.msg.fragment.too_long_fragment",
11768
16
        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
11769
16
        NULL, HFILL }},
11770
11771
16
    { &hf_isup_apm_msg_fragment_error,
11772
16
      { "Message defragmentation error", "isup.apm.msg.fragment.error",
11773
16
        FT_FRAMENUM, BASE_NONE, NULL, 0x00,
11774
16
        NULL, HFILL }},
11775
11776
16
    { &hf_isup_apm_msg_fragment_count,
11777
16
      { "Message fragment count", "isup.apm.msg.fragment.count",
11778
16
        FT_UINT32, BASE_DEC, NULL, 0x00,
11779
16
        NULL, HFILL }},
11780
11781
16
    { &hf_isup_apm_msg_reassembled_in,
11782
16
      { "Reassembled in", "isup.apm.msg.reassembled.in",
11783
16
        FT_FRAMENUM, BASE_NONE, NULL, 0x00,
11784
16
        NULL, HFILL }},
11785
11786
16
    { &hf_isup_apm_msg_reassembled_length,
11787
16
      { "Reassembled ISUP length", "isup.apm.msg.reassembled.length",
11788
16
        FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL }},
11789
11790
16
    { &hf_isup_cvr_rsp_ind,
11791
16
      { "CVR Response Ind", "isup.conn_rsp_ind",
11792
16
        FT_UINT8, BASE_DEC, VALS(isup_cvr_rsp_ind_value), BA_8BIT_MASK,
11793
16
        NULL, HFILL }},
11794
11795
16
    { &hf_isup_cvr_cg_car_ind,
11796
16
      { "CVR Circuit Group Carrier", "isup.cg_carrier_ind",
11797
16
        FT_UINT8, BASE_HEX, VALS(isup_cvr_cg_car_ind_value), BA_8BIT_MASK,
11798
16
        NULL, HFILL }},
11799
11800
16
    { &hf_isup_cvr_cg_double_seize,
11801
16
      { "Double Seize Control", "isup.cg_char_ind.doubleSeize",
11802
16
        FT_UINT8, BASE_HEX, VALS(isup_cvr_cg_double_seize_value), DC_8BIT_MASK,
11803
16
        NULL, HFILL }},
11804
11805
16
    { &hf_isup_cvr_cg_alarm_car_ind,
11806
16
      { "Alarm Carrier Indicator", "isup.cg_alarm_car_ind",
11807
16
        FT_UINT8, BASE_HEX, VALS(isup_cvr_alarm_car_ind_value), FE_8BIT_MASK,
11808
16
        NULL, HFILL }},
11809
11810
16
    { &hf_isup_cvr_cont_chk_ind,
11811
16
      { "Continuity Check Indicator", "isup.cg_alarm_cnt_chk",
11812
16
        FT_UINT8, BASE_HEX, VALS(isup_cvr_cont_chk_ind_value), HG_8BIT_MASK,
11813
16
        NULL, HFILL }},
11814
11815
16
    { &hf_isup_geo_loc_presentation_restricted_ind,
11816
16
      { "Calling Geodetic Location presentation restricted indicator",  "isup.location_presentation_restr_ind",
11817
16
        FT_UINT8, BASE_DEC, VALS(isup_location_presentation_restricted_ind_value), DC_8BIT_MASK,
11818
16
        NULL, HFILL }},
11819
11820
16
    { &hf_isup_geo_loc_screening_ind,
11821
16
      { "Calling Geodetic Location screening indicator",  "isup.location_screening_ind",
11822
16
        FT_UINT8, BASE_DEC, VALS(isup_screening_ind_enhanced_value), BA_8BIT_MASK,        /* using previously defined screening values */
11823
16
        NULL, HFILL }},
11824
11825
    /* French ISUP parameters */
11826
16
    { &hf_isup_french_coll_field,
11827
16
      { "Collection field",  "isup.french.coll_field",
11828
16
        FT_UINT8, BASE_DEC, NULL, 0x0,
11829
16
        NULL, HFILL }},
11830
11831
16
    { &hf_isup_french_msg_num,
11832
16
      { "Message number",  "isup.french.msg_num",
11833
16
        FT_UINT8, BASE_DEC, NULL, 0x0,
11834
16
        NULL, HFILL }},
11835
11836
    /* Israeli ISUP parameters */
11837
16
    { &hf_isup_israeli_charging_message_indicators_current,
11838
16
      { "Current Tariff",  "isup.israeli.cmi_current",
11839
16
        FT_UINT8, BASE_DEC, VALS(israeli_cmi_current_rate), 0x03,
11840
16
        NULL, HFILL }},
11841
11842
16
    { &hf_isup_israeli_charging_message_indicators_next,
11843
16
      { "Next Tariff",  "isup.israeli.cmi_next",
11844
16
        FT_UINT8, BASE_DEC, VALS(israeli_cmi_next_rate), 0x0C,
11845
16
        NULL, HFILL }},
11846
11847
16
    { &hf_isup_israeli_current_rate,
11848
16
      { "Current Rate",  "isup.israeli.current_rate",
11849
16
        FT_UINT16, BASE_DEC, NULL, 0x0,
11850
16
        NULL, HFILL }},
11851
11852
16
    { &hf_isup_israeli_time_indicator,
11853
16
      { "Time Indicator",  "isup.israeli.time_indicator",
11854
16
        FT_UINT8, BASE_DEC | BASE_EXT_STRING, &israeli_time_indicators_ext, 0x0,
11855
16
        NULL, HFILL }},
11856
11857
16
    { &hf_isup_israeli_next_rate,
11858
16
      { "Next Rate",  "isup.israeli.next_ratej",
11859
16
        FT_UINT16, BASE_DEC, NULL, 0x0,
11860
16
        NULL, HFILL }},
11861
11862
    /* Japan ISUP */
11863
16
    { &hf_japan_isup_redirect_capability,
11864
16
      { "Redirect possible indicator",  "isup.jpn.redirect_capability",
11865
16
        FT_UINT8, BASE_DEC, VALS(isup_jpn_redirect_capabilit_vals), 0x07,
11866
16
        NULL, HFILL }},
11867
11868
16
    { &hf_japan_isup_redirect_counter,
11869
16
      { "Redirect counter",  "isup.jpn.redirect_counter",
11870
16
        FT_UINT8, BASE_DEC, NULL, 0x0f,
11871
16
        NULL, HFILL }},
11872
11873
16
    { &hf_japan_isup_rfi_info_type,
11874
16
      { "Information Type Tag",  "isup.rfi.info_type",
11875
16
        FT_UINT8, BASE_DEC, VALS(isup_rfi_info_type_values), 0x0,
11876
16
        NULL, HFILL }},
11877
11878
16
    { &hf_japan_isup_rfi_info_len,
11879
16
      { "Length",  "isup.rfi.info_len",
11880
16
        FT_UINT8, BASE_DEC, NULL, 0x0,
11881
16
        NULL, HFILL }},
11882
11883
16
    { &hf_japan_isup_perf_redir_reason,
11884
16
      { "Performing redirect reason",  "isup.rfi.perf_redir_reason",
11885
16
        FT_UINT8, BASE_DEC, VALS(perf_redir_reason_vals), 0x7f,
11886
16
        NULL, HFILL }},
11887
11888
16
    { &hf_japan_isup_redir_pos_ind,
11889
16
      { "Redirect possible indicator at performing exchange",  "isup.rfi.redir_pos_ind",
11890
16
        FT_UINT8, BASE_DEC, VALS(redir_pos_ind_vals), 0x07,
11891
16
        NULL, HFILL }},
11892
11893
16
    { &hf_japan_isup_emerg_call_type,
11894
16
      { "Emergency Call Type",  "isup.jpn.emerg_call_type",
11895
16
        FT_UINT8, BASE_DEC, VALS(japan_isup_emerg_call_type_vals), 0x03,
11896
16
        NULL, HFILL }},
11897
11898
16
    { &hf_japan_isup_hold_at_emerg_call_disc_ind,
11899
16
      { "Hold at emergency Call Disconnection Indicators",  "isup.jpn.hold_at_emerg_call_disc_ind",
11900
16
        FT_UINT16, BASE_DEC, VALS(hold_at_emerg_call_disc_ind_vals), 0x0300,
11901
16
        NULL, HFILL }},
11902
11903
    /* Value string values the same as perf_redir_reason_vals */
11904
16
    { &hf_japan_isup_inv_redir_reason,
11905
16
      { "Invoking redirect reason",  "isup.rfi.inv_redir_reason",
11906
16
        FT_UINT8, BASE_DEC, VALS(perf_redir_reason_vals), 0x7f,
11907
16
        NULL, HFILL }},
11908
11909
16
    { &hf_japan_isup_bwd_info_type,
11910
16
      { "Information Type Tag",  "isup.jpn.bwd_info_type",
11911
16
        FT_UINT8, BASE_DEC, VALS(japan_isup_bwd_info_type_vals), 0x0,
11912
16
        NULL, HFILL }},
11913
11914
16
    { &hf_japan_isup_tag_len,
11915
16
      { "Length",  "isup.jpn.tag_len",
11916
16
        FT_UINT8, BASE_DEC, NULL, 0x0,
11917
16
        NULL, HFILL }},
11918
11919
16
    { &hf_japan_isup_add_user_cat_type,
11920
16
      { "Type of Additional User/Service Information",  "isup.jpn.add_user_cat_type",
11921
16
        FT_UINT8, BASE_DEC|BASE_RANGE_STRING, RVALS(jpn_isup_add_user_cat_type_vals), 0x0,
11922
16
        NULL, HFILL }},
11923
11924
16
    { &hf_japan_isup_type_1_add_fixed_serv_inf,
11925
16
      { "Type 1 of additional fixed service information",  "isup.jpn.type_1_add_fixed_serv_inf",
11926
16
        FT_UINT8, BASE_DEC, VALS(jpn_isup_type_1_add_fixed_serv_inf_vals), 0x0,
11927
16
        NULL, HFILL }},
11928
11929
16
    { &hf_japan_isup_type_1_add_mobile_serv_inf,
11930
16
      { "Type 1 of additional mobile service information",  "isup.jpn.type_1_add_mobile_serv_inf",
11931
16
        FT_UINT8, BASE_DEC, VALS(jpn_isup_type_1_add_mobile_serv_inf_vals), 0x0,
11932
16
        NULL, HFILL }},
11933
11934
16
    { &hf_japan_isup_type_2_add_mobile_serv_inf,
11935
16
      { "Type 2 of additional mobile service information (Communication Method)",  "isup.jpn.type_2_add_mobile_serv_inf",
11936
16
        FT_UINT8, BASE_DEC | BASE_EXT_STRING, &jpn_isup_type_2_add_mobile_serv_inf_vals_ext, 0x0,
11937
16
        NULL, HFILL }},
11938
11939
16
    { &hf_japan_isup_type_3_add_mobile_serv_inf,
11940
16
      { "Type 3 of additional mobile service information (Charging Method)",  "isup.jpn.type_3_add_mobile_serv_inf",
11941
16
        FT_UINT8, BASE_DEC, NULL, 0x0,
11942
16
        NULL, HFILL }},
11943
11944
16
    { &hf_japan_isup_reason_for_clip_fail,
11945
16
      { "Reason for CLIP failure",  "isup.jpn.reason_for_clip_fail",
11946
16
        FT_UINT8, BASE_DEC, VALS(jpn_isup_reason_for_clip_fail_vals), 0x0,
11947
16
        NULL, HFILL }},
11948
11949
16
    { &hf_japan_isup_contractor_number,
11950
16
      { "Contractor Number",  "isup.jpn.contractor_number",
11951
16
        FT_STRING, BASE_NONE, NULL, 0x0,
11952
16
        NULL, HFILL }},
11953
11954
    /* CHARGE AREA INFORMATION */
11955
16
    { &hf_japan_isup_charge_area_nat_of_info_value,
11956
16
      { "Nature of Information indicator",  "isup.charg_area_info.oddeven_indic",
11957
16
        FT_UINT8, BASE_DEC, VALS(isup_charge_area_info_nat_of_info_value), 0x7F,
11958
16
        NULL, HFILL }},
11959
11960
16
    { &hf_japan_isup_charging_info_nc_odd_digits,
11961
16
      { "NC",  "isup.charg_area_info.nc_odd_digit",
11962
16
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0x0F,
11963
16
        NULL, HFILL }},
11964
11965
16
    { &hf_japan_isup_charging_info_nc_even_digits,
11966
16
      { "NC", "isup.charg_area_info.nc_even_digit",
11967
16
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0xF0,
11968
16
        NULL, HFILL }},
11969
11970
16
    { &hf_isup_charging_info_maca_odd_digits,
11971
16
      { "MA/CA", "isup.charg_area_info.maca_odd_digit",
11972
16
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0x0F,
11973
16
        NULL, HFILL }},
11974
11975
16
    { &hf_isup_charging_info_maca_even_digits,
11976
16
      { "MA/CA", "isup.charg_area_info.maca_even_digit",
11977
16
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0xF0,
11978
16
        NULL, HFILL }},
11979
11980
    /* CARRIER INFORMATION */
11981
16
    { &hf_isup_carrier_info_iec,
11982
16
      { "IEC Indicator", "isup.carrier_info.iec",
11983
16
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_iec_indic_value), 0x00,
11984
16
        NULL, HFILL }},
11985
11986
#if 0 /* TODO: tools/checkhf.pl reported these as unused */
11987
    { &hf_isup_carrier_info_cat_of_carrier,
11988
      { "Category of Carrier", "isup.carrier_info.cat_of_carrier",
11989
        FT_UINT8, BASE_HEX, VALS(isup_carrier_info_category_value), 0x00,
11990
        NULL, HFILL }},
11991
11992
    { &hf_isup_carrier_info_type_of_carrier_info,
11993
      { "Type of Carrier", "isup.carrier_info.type_of_carrier",
11994
        FT_UINT8, BASE_HEX, VALS(isup_carrier_info_type_of_carrier_value), 0x00,
11995
        NULL, HFILL }},
11996
#endif
11997
11998
16
    { &hf_japan_isup_carrier_info_length,
11999
16
      { "Length of Carrier Information", "isup.jpn.carrier_info_length",
12000
16
        FT_UINT8, BASE_DEC, NULL, 0x0,
12001
16
        NULL, HFILL }},
12002
12003
16
    { &hf_isup_carrier_info_odd_no_digits,
12004
16
      { "CID", "isup.carrier_info.cid_odd_digit",
12005
16
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0x0F,
12006
16
        NULL, HFILL }},
12007
12008
16
    { &hf_isup_carrier_info_even_no_digits,
12009
16
      { "CID", "isup.carrier_info.cid_even_digit",
12010
16
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0xF0,
12011
16
        NULL, HFILL }},
12012
12013
16
    { &hf_isup_carrier_info_ca_odd_no_digits,
12014
16
      { "CA", "isup.carrier_info.ca_odd_digit",
12015
16
      FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0x0F,
12016
16
      NULL, HFILL }},
12017
12018
16
    { &hf_isup_carrier_info_ca_even_no_digits,
12019
16
      { "CA", "isup.carrier_info.ca_even_digit",
12020
16
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_digits_value), 0xF0,
12021
16
        NULL, HFILL }},
12022
12023
16
    { &hf_isup_carrier_info_poi_exit_HEI,
12024
16
      { "Exit POI Hierarchy", "isup.carrier_info_exit_hierarchy",
12025
16
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_poihie_value), 0x0F,
12026
16
        NULL, HFILL }},
12027
12028
16
    { &hf_isup_carrier_info_poi_entry_HEI,
12029
16
      { "Entry POI Hierarchy", "isup.carrier_info_entry_hierarchy",
12030
16
        FT_UINT8, BASE_DEC, VALS(isup_carrier_info_poihie_value), 0xF0,
12031
16
        NULL, HFILL }},
12032
12033
16
    { &hf_japan_isup_charge_delay_type,
12034
16
      { "Type of delayed charging information", "isup.japan.charge_delay_type",
12035
16
        FT_UINT8, BASE_DEC|BASE_RANGE_STRING, RVALS(japan_isup_charge_delay_type_value), 0x0,
12036
16
        NULL, HFILL }},
12037
12038
16
    { &hf_japan_isup_charge_info_type,
12039
16
      { "Charge information type", "isup.japan.chg_inf_type",
12040
16
        FT_UINT8, BASE_DEC, VALS(japan_isup_chg_info_type_value), 0x0,
12041
16
        NULL, HFILL }},
12042
12043
16
    { &hf_japan_isup_sig_elem_type,
12044
16
      { "Signal element type", "isup.japan.sig_elem_type",
12045
16
        FT_UINT8, BASE_DEC, VALS(japan_isup_sig_elem_type_values), 0x7f,
12046
16
        NULL, HFILL }},
12047
12048
16
    { &hf_japan_isup_activation_id,
12049
16
      { "Activation id", "isup.japan.activation_id",
12050
16
        FT_UINT8, BASE_DEC, NULL, 0x7F,
12051
16
        NULL, HFILL }},
12052
12053
16
    { &hf_japan_isup_op_cls,
12054
16
      { "Operation class", "isup.japan.op_cls",
12055
16
        FT_UINT8, BASE_DEC, VALS(japan_isup_op_cls_values), 0x60,
12056
16
        NULL, HFILL }},
12057
12058
16
    { &hf_japan_isup_op_type,
12059
16
      { "Operation type", "isup.japan.op_type",
12060
16
        FT_UINT8, BASE_DEC, VALS(japan_isup_op_type_values), 0x1f,
12061
16
        NULL, HFILL }},
12062
12063
16
    { &hf_japan_isup_charging_party_type,
12064
16
      { "Charging party type", "isup.japan.charging_party_type",
12065
16
        FT_UINT8, BASE_DEC, VALS(japan_isup_charging_party_type_values), 0x70,
12066
16
        NULL, HFILL }},
12067
12068
16
    { &hf_japan_isup_utp,
12069
16
      { "Unit per Time Period (UTP)", "isup.japan.utp",
12070
16
        FT_UINT8, BASE_DEC, VALS(japan_isup_utp_values), 0x0,
12071
16
        NULL, HFILL }},
12072
12073
16
    { &hf_japan_isup_crci1,
12074
16
      { "Charge rate information category 1 (CRIC 1)", "isup.japan.crci1",
12075
16
        FT_UINT8, BASE_DEC, VALS(japan_isup_crci1_values), 0x7f,
12076
16
        NULL, HFILL }},
12077
12078
16
    { &hf_japan_isup_crci2,
12079
16
      { "Charge rate information category 2 (CRIC 2)", "isup.japan.crci2",
12080
16
        FT_UINT8, BASE_DEC, VALS(japan_isup_crci1_values), 0x7f,
12081
16
        NULL, HFILL }},
12082
12083
16
    { &hf_japan_isup_crci1_len,
12084
16
      { "Length",  "isup.japan.crci1_len",
12085
16
        FT_UINT8, BASE_DEC, NULL, 0x0,
12086
16
        NULL, HFILL }},
12087
12088
16
    { &hf_japan_isup_iu,
12089
16
      { "Initial units (IU)",  "isup.japan.iu",
12090
16
        FT_STRING, BASE_NONE, NULL, 0x0,
12091
16
        NULL, HFILL }},
12092
12093
16
    { &hf_japan_isup_dcr,
12094
16
      { "Daytime Charge rate (DCR)",  "isup.japan.dcr",
12095
16
        FT_STRING, BASE_NONE, NULL, 0x0,
12096
16
        NULL, HFILL }},
12097
12098
16
    { &hf_japan_isup_ecr,
12099
16
      { "Evening Charge rate (ECR)",  "isup.japan.ecr",
12100
16
        FT_STRING, BASE_NONE, NULL, 0x0,
12101
16
        NULL, HFILL }},
12102
12103
16
    { &hf_japan_isup_ncr,
12104
16
      { "Nighttime Charge rate (NCR)",  "isup.japan.ncr",
12105
16
        FT_STRING, BASE_NONE, NULL, 0x0,
12106
16
        NULL, HFILL }},
12107
12108
16
    { &hf_japan_isup_scr,
12109
16
      { "Spare charge rate (SCR)",  "isup.japan.scr",
12110
16
        FT_STRING, BASE_NONE, NULL, 0x0,
12111
16
        NULL, HFILL }},
12112
12113
16
    { &hf_japan_isup_collecting_method,
12114
16
      { "Charging party type", "isup.japan.collecting_method",
12115
16
        FT_UINT8, BASE_DEC, VALS(japan_isup_collecting_method_values), 0x0f,
12116
16
        NULL, HFILL }},
12117
12118
16
    { &hf_japan_isup_tariff_rate_pres,
12119
16
      { "Tariff rate presentation", "isup.japan.tariff_rate_pres",
12120
16
        FT_UINT8, BASE_DEC, VALS(japan_isup_tariff_rate_pres_values), 0x7f,
12121
16
        NULL, HFILL }},
12122
12123
      /* Generated from convert_proto_tree_add_text.pl */
12124
16
      { &hf_isup_cause_indicators, { "Cause indicators (-> Q.850)", "isup.cause_indicators", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12125
16
      { &hf_isup_diagnostic, { "Diagnostic", "isup.diagnostic", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12126
16
      { &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 }},
12127
16
      { &hf_isup_call_identity, { "Call identity", "isup.call_identity", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12128
16
      { &hf_isup_signalling_point_code, { "Signalling Point Code", "isup.signalling_point_code", FT_UINT16, BASE_DEC, NULL, 0x3FFF, NULL, HFILL }},
12129
16
      { &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 }},
12130
16
      { &hf_isup_idp, { "IDP", "isup.idp", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12131
16
      { &hf_isup_dsp, { "DSP", "isup.dsp", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12132
16
      { &hf_isup_idi, { "IDI", "isup.idi", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12133
16
      { &hf_isup_configuration_data, { "Configuration data", "isup.configuration_data", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12134
16
      { &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 }},
12135
16
      { &hf_isup_tunnelled_protocol_data, { "Tunnelled Protocol Data", "isup.tunnelled_protocol_data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12136
16
      { &hf_isup_network_id_length_indicator, { "Network ID Length indicator", "isup.network_id_length_indicator", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12137
16
      { &hf_isup_network_id, { "Network ID", "isup.network_id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12138
16
      { &hf_isup_app_transport_param_field8, { "Application transport parameter fields", "isup.app_transport_param_field", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12139
16
      { &hf_isup_app_transport_param_field16, { "Application transport parameter fields", "isup.app_transport_param_field", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12140
16
      { &hf_isup_app_transport_instruction_indicator, { "Application transport instruction indicators", "isup.app_transport_instruction_indicator", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12141
16
      { &hf_isup_apm_seg_indicator, { "APM segmentation indicator", "isup.apm_seg_indicator", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12142
16
      { &hf_isup_address_digits, { "Address digits", "isup.address_digits", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12143
16
      { &hf_isup_apm_user_info_field, { "APM-user information field", "isup.apm_user_info_field", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12144
16
      { &hf_isup_local_reference, { "Local Reference", "isup.local_reference", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12145
16
      { &hf_isup_protocol_class, { "Protocol Class", "isup.protocol_class", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12146
16
      { &hf_isup_credit, { "Credit", "isup.credit", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12147
16
      { &hf_isup_network_identity, { "Network Identity", "isup.network_identity", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12148
16
      { &hf_isup_binary_code, { "Binary Code", "isup.binary_code", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12149
16
      { &hf_isup_user_service_information, { "User service information (-> Q.931 Bearer_capability)", "isup.user_service_information", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12150
16
      { &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 }},
12151
16
      { &hf_isup_origination_isc_point_code, { "Origination ISC Point Code", "isup.origination_isc_point_code", FT_UINT16, BASE_DEC, NULL, 0x3FFF, NULL, HFILL }},
12152
16
      { &hf_isup_call_history_info, { "Call history info", "isup.call_history_info", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12153
16
      { &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 }},
12154
16
      { &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 }},
12155
16
      { &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 }},
12156
16
      { &hf_isup_remote_operations, { "Remote operations", "isup.remote_operations", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12157
16
      { &hf_isup_feature_code, { "Feature Code", "isup.feature_code", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12158
16
      { &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 }},
12159
16
      { &hf_isup_call_diversion_information, { "Call diversion information", "isup.call_diversion_information", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12160
16
      { &hf_isup_echo_control_information, { "Echo control information", "isup.echo_control_information", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12161
16
      { &hf_isup_message_compatibility_information, { "Message compatibility information", "isup.message_compatibility_information", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12162
16
      { &hf_isup_upgraded_parameter, { "Upgraded parameter", "isup.upgraded_parameter", FT_UINT8, BASE_DEC|BASE_EXT_STRING, &isup_parameter_type_value_ext, 0x0, NULL, HFILL }},
12163
16
      { &hf_isup_instruction_indicators, { "Instruction indicators", "isup.instruction_indicators", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12164
16
      { &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 }},
12165
16
      { &hf_isup_precedence_level, { "Precedence Level", "isup.precedence_level", FT_UINT8, BASE_DEC, VALS(isup_mlpp_precedence_level_vals), 0x0F, NULL, HFILL }},
12166
16
      { &hf_isup_mlpp_service_domain, { "MLPP service domain", "isup.mlpp_service_domain", FT_UINT24, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12167
16
      { &hf_isup_mcid_request_indicators, { "MCID request indicators", "isup.mcid_request_indicators", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12168
16
      { &hf_isup_mcid_response_indicators, { "MCID response indicators", "isup.mcid_response_indicators", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12169
16
      { &hf_isup_hop_counter, { "Hop counter", "isup.hop_counter", FT_UINT8, BASE_DEC, NULL, EDCBA_8BIT_MASK, NULL, HFILL }},
12170
16
      { &hf_isup_originating_line_info, { "Originating line info", "isup.originating_line_info", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12171
16
      { &hf_isup_presentation_indicator, { "Presentation indicator", "isup.presentation_indicator", FT_UINT8, BASE_DEC, VALS(isup_redirection_presentation_indicator_vals), BA_8BIT_MASK, NULL, HFILL }},
12172
16
      { &hf_isup_call_transfer_identity, { "Call transfer identity", "isup.call_transfer_identity", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12173
16
      { &hf_isup_loop_prevention_indicator_type, { "Type", "isup.loop_prevention_indicator_type", FT_BOOLEAN, 8, TFS(&tfs_response_request), A_8BIT_MASK, NULL, HFILL }},
12174
16
      { &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 }},
12175
16
      { &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 }},
12176
16
      { &hf_isup_redirect_capability, { "Redirect capability", "isup.redirect_capability", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12177
16
      { &hf_isup_backward_gvns, { "Backward GVNS", "isup.backward_gvns", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12178
16
      { &hf_isup_correlation_id, { "Correlation ID (-> Q.1281)", "isup.correlation_id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12179
16
      { &hf_isup_scf_id, { "SCF ID (-> Q.1281)", "isup.scf_id", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12180
16
      { &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 }},
12181
16
      { &hf_isup_display_information, { "Display information (-> Q.931)", "isup.display_information", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12182
16
      { &hf_isup_uid_action_indicators, { "UID action indicators", "isup.uid_action_indicators", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12183
16
      { &hf_isup_uid_capability_indicators, { "UID capability indicators", "isup.uid_capability_indicators", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL }},
12184
16
      { &hf_isup_redirect_counter, { "Redirect counter", "isup.redirect_counter", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
12185
16
      { &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 }},
12186
16
      { &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 }},
12187
16
      { &hf_isup_geo_loc_shape_description, { "Shape description", "isup.shape_description", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
12188
16
      { &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 }},
12189
16
      { &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 }},
12190
16
  };
12191
12192
/* Setup protocol subtree array */
12193
16
  static int *ett[] = {
12194
16
    &ett_isup,
12195
16
    &ett_isup_parameter,
12196
16
    &ett_isup_address_digits,
12197
16
    &ett_isup_carrier_info,
12198
16
    &ett_isup_pass_along_message,
12199
16
    &ett_isup_circuit_state_ind,
12200
16
    &ett_bat_ase,
12201
16
    &ett_bat_ase_element,
12202
16
    &ett_bat_ase_iwfa,
12203
16
    &ett_scs,
12204
16
    &ett_acs,
12205
16
    &ett_isup_apm_msg_fragment,
12206
16
    &ett_isup_apm_msg_fragments,
12207
16
    &ett_isup_range,
12208
16
    &ett_app_transport_fields,
12209
16
    &ett_app_transport,
12210
16
    &ett_apm_seg_indicator,
12211
16
    &ett_echo_control_information,
12212
16
    &ett_instruction_indicators,
12213
16
    &ett_message_compatibility_information,
12214
16
  };
12215
12216
16
  static ei_register_info ei[] = {
12217
16
    { &ei_isup_format_national_matter, { "isup.format_national_matter", PI_PROTOCOL, PI_NOTE, "Format is a national matter", EXPFILL }},
12218
16
    { &ei_isup_message_type_unknown, { "isup.message_type.unknown", PI_PROTOCOL, PI_WARN, "Unknown Message type (possibly reserved/used in former ISUP version)", EXPFILL }},
12219
16
    { &ei_isup_not_dissected_yet, { "isup.not_dissected_yet", PI_UNDECODED, PI_WARN, "Not dissected yet", EXPFILL }},
12220
16
    { &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 }},
12221
16
    { &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 }},
12222
16
    { &ei_isup_empty_number, { "isup.empty_number", PI_PROTOCOL, PI_NOTE, "(empty) number", EXPFILL }},
12223
16
    { &ei_isup_too_many_digits, { "isup.too_many_digits", PI_MALFORMED, PI_ERROR, "Too many digits", EXPFILL }},
12224
16
    { &ei_isup_opt_par_length_err, { "isup.opt_par_length_err", PI_MALFORMED, PI_ERROR, "Optional parameter length is wrong", EXPFILL }}
12225
16
  };
12226
12227
16
  static const enum_val_t isup_variants[] = {
12228
16
    {"ITU",         "ITU Standard",              ISUP_ITU_STANDARD_VARIANT},
12229
16
    {"French",      "French National Standard",  ISUP_FRENCH_VARIANT},
12230
16
    {"Israeli",     "Israeli National Standard", ISUP_ISRAELI_VARIANT},
12231
16
    {"Russian",     "Russian National Standard", ISUP_RUSSIAN_VARIANT},
12232
16
    {"Japan",       "Japan National Standard",   ISUP_JAPAN_VARIANT},
12233
16
    {"Japan_TTC",   "Japan National Standard (TTC)",   ISUP_JAPAN_TTC_VARIANT},
12234
16
    {NULL, NULL, -1}
12235
16
  };
12236
12237
16
  module_t *isup_module;
12238
16
  expert_module_t* expert_isup;
12239
12240
/* Register the protocol name and description */
12241
16
  proto_isup = proto_register_protocol("ISDN User Part",
12242
16
                                       "ISUP", "isup");
12243
12244
16
  isup_handle = register_dissector("isup", dissect_isup, proto_isup);
12245
12246
/* Required function calls to register the header fields and subtrees used */
12247
16
  proto_register_field_array(proto_isup, hf, array_length(hf));
12248
16
  proto_register_subtree_array(ett, array_length(ett));
12249
16
  expert_isup = expert_register_protocol(proto_isup);
12250
16
  expert_register_field_array(expert_isup, ei, array_length(ei));
12251
12252
16
  isup_tap = register_tap("isup");
12253
12254
16
  isup_module = prefs_register_protocol(proto_isup, NULL);
12255
12256
16
  prefs_register_enum_preference(isup_module, "variant",
12257
16
                    "Select Standard or national ISUP variant",
12258
16
                    "Note national variants may not be fully supported",
12259
16
                    &g_isup_variant, isup_variants, false);
12260
12261
12262
16
  prefs_register_bool_preference(isup_module, "show_cic_in_info", "Show CIC in Info column",
12263
16
                                 "Show the CIC value (in addition to the message type) in the Info column",
12264
16
                                 &isup_show_cic_in_info);
12265
12266
16
  prefs_register_bool_preference(isup_module, "defragment_apm",
12267
16
                                 "Reassemble APM messages",
12268
16
                                 "Whether APM messages datagrams should be reassembled",
12269
16
                                 &isup_apm_desegment);
12270
12271
  /* Register the stats_tree */
12272
16
  stats_tree_cfg *st_config = stats_tree_register("isup", "isup_msg", "_ISUP Messages",
12273
16
                                 0, msg_stats_tree_packet, msg_stats_tree_init, NULL);
12274
16
  stats_tree_set_group(st_config, REGISTER_TELEPHONY_GROUP_UNSORTED);
12275
12276
16
  register_external_value_string_ext("isup_message_type_value_acro_ext", &isup_message_type_value_acro_ext);
12277
16
}
12278
12279
12280
/* ------------------------------------------------------------------ */
12281
/* Register isup with the sub-laying MTP L3 dissector */
12282
void
12283
proto_reg_handoff_isup(void)
12284
16
{
12285
16
  dissector_handle_t application_isup_handle;
12286
12287
16
  application_isup_handle = create_dissector_handle(dissect_application_isup, proto_isup);
12288
16
  dissector_add_uint("mtp3.service_indicator", MTP_SI_ISUP, isup_handle);
12289
16
  dissector_add_string("media_type", "application/isup", application_isup_handle);
12290
16
  dissector_add_string("tali.opcode", "isot", isup_handle);
12291
12292
16
}
12293
12294
void
12295
proto_register_bicc(void)
12296
16
{
12297
/* Setup list of header fields  See Section 1.6.1 for details*/
12298
16
  static hf_register_info hf[] = {
12299
16
    { &hf_bicc_cic,
12300
16
      { "Call identification Code (CIC)",           "bicc.cic",
12301
16
        FT_UINT32, BASE_DEC, NULL, 0x0,
12302
16
        NULL, HFILL }},
12303
16
    { &hf_bicc_continuity_check_indicator,
12304
16
      { "Continuity Indicator",  "bicc.continuity_check_indicator",
12305
16
        FT_UINT8, BASE_HEX, VALS(bicc_continuity_check_ind_value), DC_8BIT_MASK,
12306
16
        NULL, HFILL }},
12307
16
    { &hf_bicc_forw_call_end_to_end_method_indicator,
12308
16
      { "End-to-end method indicator",  "bicc.forw_call_end_to_end_method_indicator",
12309
16
        FT_UINT16, BASE_HEX, VALS(bicc_end_to_end_method_ind_value), CB_16BIT_MASK,
12310
16
        NULL, HFILL }},
12311
16
    { &hf_bicc_backw_call_end_to_end_method_ind,
12312
16
      { "End-to-end method indicator",  "bicc.backw_call_end_to_end_method_indicator",
12313
16
        FT_UINT16, BASE_HEX, VALS(bicc_end_to_end_method_ind_value), HG_16BIT_MASK,
12314
16
        NULL, HFILL }},
12315
16
    { &hf_bicc_backw_call_end_to_end_info_ind,
12316
16
      { "End-to-end information indicator",  "bicc.backw_call_end_to_end_information_indicator",
12317
16
        FT_BOOLEAN, 16, TFS(&bicc_end_to_end_info_ind_value), J_16BIT_MASK,
12318
16
        NULL, HFILL }},
12319
16
    { &hf_bicc_backw_call_isdn_user_part_ind,
12320
16
      { "BICC indicator",  "bicc.backw_call_isdn_user_part_indicator",
12321
16
        FT_BOOLEAN, 16, TFS(&bicc_ISDN_user_part_ind_value), K_16BIT_MASK,
12322
16
        NULL, HFILL }},
12323
16
    { &hf_bicc_backw_call_sccp_method_ind,
12324
16
      { "SCCP method indicator",  "bicc.backw_call_sccp_method_indicator",
12325
16
        FT_UINT16, BASE_HEX, VALS(bicc_SCCP_method_ind_value), PO_16BIT_MASK,
12326
16
        NULL, HFILL }},
12327
16
    { &hf_bicc_forw_call_end_to_end_info_indicator,
12328
16
      { "End-to-end information indicator",  "bicc.forw_call_end_to_end_information_indicator",
12329
16
        FT_BOOLEAN, 16, TFS(&bicc_end_to_end_info_ind_value), E_16BIT_MASK,
12330
16
        NULL, HFILL }},
12331
16
    { &hf_bicc_forw_call_isdn_user_part_indicator,
12332
16
      { "BICC indicator",  "bicc.forw_call_isdn_user_part_indicator",
12333
16
        FT_BOOLEAN, 16, TFS(&bicc_ISDN_user_part_ind_value), F_16BIT_MASK,
12334
16
        NULL, HFILL }},
12335
16
    { &hf_bicc_forw_call_preferences_indicator,
12336
16
      { "BICC preference indicator",  "bicc.forw_call_preferences_indicator",
12337
16
        FT_UINT16, BASE_HEX, VALS(bicc_preferences_ind_value), HG_16BIT_MASK,
12338
16
        NULL, HFILL }},
12339
16
    { &hf_bicc_forw_call_sccp_method_indicator,
12340
16
      { "SCCP method indicator",  "bicc.forw_call_sccp_method_indicator",
12341
16
        FT_UINT16, BASE_HEX, VALS(bicc_SCCP_method_ind_value), KJ_16BIT_MASK,
12342
16
        NULL, HFILL }},
12343
16
  };
12344
12345
/* Setup protocol subtree array */
12346
16
  static int *ett[] = {
12347
16
    &ett_bicc
12348
16
  };
12349
12350
16
  proto_bicc = proto_register_protocol("Bearer Independent Call Control",
12351
16
                                       "BICC", "bicc");
12352
12353
16
  bicc_handle = register_dissector("bicc", dissect_bicc, proto_bicc);
12354
12355
/* Required function calls to register the header fields and subtrees used */
12356
16
  proto_register_field_array(proto_bicc, hf, array_length(hf));
12357
16
  proto_register_subtree_array(ett, array_length(ett));
12358
12359
16
  reassembly_table_register(&isup_apm_msg_reassembly_table,
12360
16
                         &addresses_reassembly_table_functions);
12361
12362
16
}
12363
12364
/* Register isup with the sub-laying MTP L3 dissector */
12365
void
12366
proto_reg_handoff_bicc(void)
12367
16
{
12368
16
  sdp_handle     = find_dissector_add_dependency("sdp", proto_isup);
12369
16
  q931_ie_handle = find_dissector_add_dependency("q931.ie", proto_isup);
12370
12371
16
  dissector_add_uint("mtp3.service_indicator", MTP_SI_BICC, bicc_handle);
12372
16
  dissector_add_uint("sctp.ppi", BICC_PAYLOAD_PROTOCOL_ID, bicc_handle);
12373
16
}
12374
12375
/*
12376
 * Editor modelines
12377
 *
12378
 * Local Variables:
12379
 * c-basic-offset: 2
12380
 * tab-width: 8
12381
 * indent-tabs-mode: nil
12382
 * End:
12383
 *
12384
 * ex: set shiftwidth=2 tabstop=8 expandtab:
12385
 * :indentSize=2:tabSize=8:noTabs=true:
12386
 */