epan/dissectors/packet-iua.c

   1 /* packet-iua.c
   2  * Routines for ISDN Q.921-User Adaptation Layer dissection
   3  *
   4  * It is hopefully (needs testing) compliant to
   5  *   http://www.ietf.org/rfc/rfc3057.txt
   6  *   http://www.ietf.org/internet-drafts/draft-ietf-sigtran-iua-imp-guide-01.txt
   7  * To do: - provide better handling of length parameters
   8  *
   9  * Copyright 2002, Michael Tuexen <tuexen [AT] fh-muenster.de>
  10  *
  11  * Wireshark - Network traffic analyzer
  12  * By Gerald Combs <gerald@wireshark.org>
  13  * Copyright 1998 Gerald Combs
  14  *
  15  * Copied from README.developer
  16  *
  17  * SPDX-License-Identifier: GPL-2.0-or-later
  18  */
  19
  20 #include "config.h"
  21
  22 #include <epan/packet.h>
  23 #include <epan/prefs.h>
  24 #include <epan/sctpppids.h>
  25 #include <epan/lapd_sapi.h>
  26 #include <wsutil/str_util.h>
  27
  28 void proto_register_iua(void);
  29 void proto_reg_handoff_iua(void);
  30
  31 static module_t *iua_module;
  32
  33 static dissector_table_t lapd_gsm_sapi_dissector_table;
  34
  35 /* Whether to use GSM SAPI vals or not */
  36 static gboolean global_iua_gsm_sapis = TRUE;
  37
  38 /* Initialize the protocol and registered fields */
  39 static int proto_iua                = -1;
  40 static int hf_int_interface_id      = -1;
  41 static int hf_text_interface_id     = -1;
  42 static int hf_info_string           = -1;
  43 static int hf_dlci_zero_bit         = -1;
  44 static int hf_dlci_spare_bit        = -1;
  45 static int hf_dlci_sapi             = -1;
  46 static int hf_dlci_gsm_sapi         = -1;
  47 static int hf_dlci_one_bit          = -1;
  48 static int hf_dlci_tei              = -1;
  49 static int hf_dlci_spare            = -1;
  50 static int hf_diag_info             = -1;
  51 static int hf_interface_range_start = -1;
  52 static int hf_interface_range_end   = -1;
  53 static int hf_heartbeat_data        = -1;
  54 static int hf_asp_reason            = -1;
  55 static int hf_traffic_mode_type     = -1;
  56 static int hf_error_code            = -1;
  57 static int hf_error_code_ig         = -1;
  58 static int hf_status_type           = -1;
  59 static int hf_status_id             = -1;
  60 static int hf_release_reason        = -1;
  61 static int hf_tei_status            = -1;
  62 static int hf_asp_id                = -1;
  63 static int hf_parameter_tag         = -1;
  64 static int hf_parameter_tag_ig      = -1;
  65 static int hf_parameter_length      = -1;
  66 static int hf_parameter_value       = -1;
  67 static int hf_parameter_padding     = -1;
  68 static int hf_version               = -1;
  69 static int hf_reserved              = -1;
  70 static int hf_message_class         = -1;
  71 static int hf_message_type          = -1;
  72 static int hf_message_length        = -1;
  73
  74 /* Initialize the subtree pointers */
  75 static gint ett_iua                 = -1;
  76 static gint ett_iua_parameter       = -1;
  77
  78 /* stores the current SAPI value */
  79 static guint8 sapi_val;
  80 static gboolean sapi_val_assigned   = FALSE;
  81
  82 /* option setable via preferences, default is plain RFC 3057 */
  83 static gboolean support_IG          = FALSE;
  84
  85 static dissector_handle_t q931_handle;
  86 static dissector_handle_t x25_handle;
  87 static dissector_handle_t iua_handle;
  88
  89 #define ADD_PADDING(x) ((((x) + 3) >> 2) << 2)
  90
  91 #define PARAMETER_TAG_LENGTH    2
  92 #define PARAMETER_LENGTH_LENGTH 2
  93 #define PARAMETER_HEADER_LENGTH (PARAMETER_TAG_LENGTH + PARAMETER_LENGTH_LENGTH)
  94
  95 #define PARAMETER_TAG_OFFSET    0
  96 #define PARAMETER_LENGTH_OFFSET (PARAMETER_TAG_OFFSET + PARAMETER_TAG_LENGTH)
  97 #define PARAMETER_VALUE_OFFSET  (PARAMETER_LENGTH_OFFSET + PARAMETER_LENGTH_LENGTH)
  98 #define PARAMETER_HEADER_OFFSET PARAMETER_TAG_OFFSET
  99
 100 #define INT_INTERFACE_ID_LENGTH 4
 101
 102 static void
 103 dissect_int_interface_identifier_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 104 {
 105   guint16 number_of_ids, id_number;
 106   gint offset;
 107
 108   number_of_ids= (tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH) / INT_INTERFACE_ID_LENGTH;
 109   offset = PARAMETER_VALUE_OFFSET;
 110
 111   proto_item_append_text(parameter_item, " (");
 112   for (id_number = 0; id_number < number_of_ids; id_number++) {
 113     proto_tree_add_item(parameter_tree, hf_int_interface_id, parameter_tvb, offset, INT_INTERFACE_ID_LENGTH, ENC_BIG_ENDIAN);
 114     proto_item_append_text(parameter_item, (id_number > 0) ? ", %d" : "%d", tvb_get_ntohl(parameter_tvb, offset));
 115     offset += INT_INTERFACE_ID_LENGTH;
 116   }
 117   proto_item_append_text(parameter_item, ")");
 118 }
 119
 120 #define TEXT_INTERFACE_ID_OFFSET PARAMETER_VALUE_OFFSET
 121
 122 static void
 123 dissect_text_interface_identifier_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 124 {
 125   guint16 interface_id_length;
 126
 127   interface_id_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH;
 128
 129   proto_tree_add_item(parameter_tree, hf_text_interface_id, parameter_tvb, TEXT_INTERFACE_ID_OFFSET, interface_id_length, ENC_ASCII|ENC_NA);
 130   proto_item_append_text(parameter_item, " (%.*s)", interface_id_length,
 131                          tvb_format_text(parameter_tvb, TEXT_INTERFACE_ID_OFFSET, interface_id_length));
 132 }
 133
 134 #define INFO_STRING_OFFSET PARAMETER_VALUE_OFFSET
 135
 136 static void
 137 dissect_info_string_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 138 {
 139   guint16 info_string_length;
 140
 141   info_string_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH;
 142   proto_tree_add_item(parameter_tree, hf_info_string, parameter_tvb, INFO_STRING_OFFSET, info_string_length, ENC_ASCII|ENC_NA);
 143   proto_item_append_text(parameter_item, " (%.*s)", info_string_length,
 144                          tvb_format_text(parameter_tvb, INFO_STRING_OFFSET, info_string_length));
 145 }
 146
 147 #define DLCI_SAPI_LENGTH  1
 148 #define DLCI_TEI_LENGTH   1
 149 #define DLCI_SPARE_LENGTH 2
 150
 151 #define DLCI_SAPI_OFFSET  PARAMETER_VALUE_OFFSET
 152 #define DLCI_TEI_OFFSET   (DLCI_SAPI_OFFSET + DLCI_SAPI_LENGTH)
 153 #define DLCI_SPARE_OFFSET (DLCI_TEI_OFFSET + DLCI_TEI_LENGTH)
 154
 155 #define ZERO_BIT_MASK     0x01
 156 #define SPARE_BIT_MASK    0x02
 157 #define SAPI_MASK         0xfc
 158 #define SAPI_SHIFT        2
 159 #define ONE_BIT_MASK      0x01
 160 #define TEI_MASK          0xfe
 161
 162 /* SAPI values taken from Q.921 */
 163 #define SAPI_VAL_CALL_CONTROL 0
 164 #define SAPI_VAL_Q931_PACKET  1
 165 #define SAPI_VAL_TELACTION    12
 166 #define SAPI_VAL_X25          16
 167 #define SAPI_VAL_LAYER_2      63
 168 static const value_string sapi_values[] = {
 169   { SAPI_VAL_CALL_CONTROL,    "Call control procedures" },
 170   { SAPI_VAL_Q931_PACKET,     "Q.931 packet mode communication" },
 171   { SAPI_VAL_TELACTION,       "Teleaction communication" },
 172   { SAPI_VAL_X25,             "X.25 packet communication" },
 173   { SAPI_VAL_LAYER_2,         "Layer 2 management procedures" },
 174   { 0,                        NULL }
 175 };
 176
 177 static const value_string gsm_sapi_vals[] = {
 178   { LAPD_GSM_SAPI_RA_SIG_PROC,  "Radio signalling procedures" },
 179   { LAPD_GSM_SAPI_NOT_USED_1,   "(Not used in GSM PLMN)" },
 180   { LAPD_GSM_SAPI_NOT_USED_16,  "(Not used in GSM PLMN)" },
 181   { LAPD_GSM_SAPI_OM_PROC,      "Operation and maintenance procedure" },
 182   { LAPD_SAPI_L2,               "Layer 2 management procedures" },
 183   { 0,                          NULL }
 184 };
 185
 186 static void
 187 dissect_dlci_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree)
 188 {
 189   proto_tree_add_item(parameter_tree, hf_dlci_zero_bit,  parameter_tvb, DLCI_SAPI_OFFSET,  DLCI_SAPI_LENGTH,  ENC_BIG_ENDIAN);
 190   proto_tree_add_item(parameter_tree, hf_dlci_spare_bit, parameter_tvb, DLCI_SAPI_OFFSET,  DLCI_SAPI_LENGTH,  ENC_BIG_ENDIAN);
 191   /* Add the SAPI + some explanatory text, store the SAPI value so that we can later how to
 192    * dissect the protocol data */
 193   if(global_iua_gsm_sapis) {
 194     proto_tree_add_item(parameter_tree, hf_dlci_gsm_sapi, parameter_tvb, DLCI_SAPI_OFFSET,  DLCI_SAPI_LENGTH,  ENC_BIG_ENDIAN);
 195   } else {
 196     proto_tree_add_item(parameter_tree, hf_dlci_sapi, parameter_tvb, DLCI_SAPI_OFFSET,  DLCI_SAPI_LENGTH,  ENC_BIG_ENDIAN);
 197   }
 198   sapi_val = (tvb_get_guint8(parameter_tvb, DLCI_SAPI_OFFSET) & SAPI_MASK) >> SAPI_SHIFT;
 199   sapi_val_assigned = TRUE;
 200
 201   proto_tree_add_item(parameter_tree, hf_dlci_one_bit,   parameter_tvb, DLCI_TEI_OFFSET,   DLCI_TEI_LENGTH,   ENC_BIG_ENDIAN);
 202   proto_tree_add_item(parameter_tree, hf_dlci_tei,       parameter_tvb, DLCI_TEI_OFFSET,   DLCI_TEI_LENGTH,   ENC_BIG_ENDIAN);
 203   proto_tree_add_item(parameter_tree, hf_dlci_spare,     parameter_tvb, DLCI_SPARE_OFFSET, DLCI_SPARE_LENGTH, ENC_BIG_ENDIAN);
 204 }
 205
 206 static void
 207 dissect_diagnostic_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 208 {
 209   guint16 diag_info_length;
 210
 211   diag_info_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH;
 212   proto_tree_add_item(parameter_tree, hf_diag_info, parameter_tvb, PARAMETER_VALUE_OFFSET, diag_info_length, ENC_NA);
 213   proto_item_append_text(parameter_item, " (%u byte%s)", diag_info_length, plurality(diag_info_length, "", "s"));
 214 }
 215
 216 #define START_LENGTH 4
 217 #define END_LENGTH   4
 218 #define INTERVAL_LENGTH (START_LENGTH + END_LENGTH)
 219
 220 #define START_OFFSET 0
 221 #define END_OFFSET   (START_OFFSET + START_LENGTH)
 222
 223 static void
 224 dissect_integer_range_interface_identifier_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 225 {
 226   guint16 number_of_ranges, range_number;
 227   gint offset;
 228
 229   number_of_ranges = (tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH) / INTERVAL_LENGTH;
 230   offset = PARAMETER_VALUE_OFFSET;
 231   proto_item_append_text(parameter_item, " (");
 232   for (range_number = 0; range_number < number_of_ranges; range_number++) {
 233     proto_tree_add_item(parameter_tree, hf_interface_range_start, parameter_tvb, offset + START_OFFSET, START_LENGTH, ENC_BIG_ENDIAN);
 234     proto_tree_add_item(parameter_tree, hf_interface_range_end,   parameter_tvb, offset + END_OFFSET,   END_LENGTH,   ENC_BIG_ENDIAN);
 235     proto_item_append_text(parameter_item, (range_number > 0) ? ", %d-%d" : "%d-%d",
 236                            tvb_get_ntohl(parameter_tvb, offset + START_OFFSET), tvb_get_ntohl(parameter_tvb, offset + END_OFFSET));
 237     offset += INTERVAL_LENGTH;
 238   }
 239   proto_item_append_text(parameter_item, ")");
 240 }
 241
 242 #define HEARTBEAT_DATA_OFFSET PARAMETER_VALUE_OFFSET
 243
 244 static void
 245 dissect_heartbeat_data_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 246 {
 247   guint16 heartbeat_data_length;
 248
 249   heartbeat_data_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH;
 250   proto_tree_add_item(parameter_tree, hf_heartbeat_data, parameter_tvb, HEARTBEAT_DATA_OFFSET, heartbeat_data_length, ENC_NA);
 251   proto_item_append_text(parameter_item, " (%u byte%s)", heartbeat_data_length, plurality(heartbeat_data_length, "", "s"));
 252 }
 253
 254 #define ASP_MGMT_REASON   1
 255
 256 static const value_string asp_reason_values[] = {
 257   { ASP_MGMT_REASON,      "Management inhibit" },
 258   { 0,                    NULL } };
 259
 260 #define ASP_REASON_LENGTH 4
 261 #define ASP_REASON_OFFSET PARAMETER_VALUE_OFFSET
 262
 263 static void
 264 dissect_asp_reason_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 265 {
 266   proto_tree_add_item(parameter_tree, hf_asp_reason, parameter_tvb, ASP_REASON_OFFSET, ASP_REASON_LENGTH, ENC_BIG_ENDIAN);
 267   proto_item_append_text(parameter_item, " (%s)", val_to_str_const(tvb_get_ntohl(parameter_tvb, ASP_REASON_OFFSET), asp_reason_values, "unknown"));
 268 }
 269
 270 #define OVER_RIDE_TRAFFIC_MODE_TYPE  1
 271 #define LOAD_SHARE_TRAFFIC_MODE_TYPE 2
 272
 273 static const value_string traffic_mode_type_values[] = {
 274   { OVER_RIDE_TRAFFIC_MODE_TYPE,      "Over-ride" },
 275   { LOAD_SHARE_TRAFFIC_MODE_TYPE,     "Load-share" },
 276   { 0,                    NULL } };
 277
 278 #define TRAFFIC_MODE_TYPE_LENGTH 4
 279 #define TRAFFIC_MODE_TYPE_OFFSET PARAMETER_VALUE_OFFSET
 280
 281 static void
 282 dissect_traffic_mode_type_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 283 {
 284   proto_tree_add_item(parameter_tree, hf_traffic_mode_type, parameter_tvb, TRAFFIC_MODE_TYPE_OFFSET, TRAFFIC_MODE_TYPE_LENGTH, ENC_BIG_ENDIAN);
 285   proto_item_append_text(parameter_item, " (%s)",
 286                          val_to_str_const(tvb_get_ntohl(parameter_tvb, TRAFFIC_MODE_TYPE_OFFSET), traffic_mode_type_values, "unknown"));
 287 }
 288
 289 #define INVALID_VERSION_ERROR                         0x01
 290 #define INVALID_INTERFACE_IDENTIFIER_ERROR            0x02
 291 #define UNSUPPORTED_MESSAGE_CLASS_ERROR               0x03
 292 #define UNSUPPORTED_MESSAGE_TYPE_ERROR                0x04
 293 #define UNSUPPORTED_TRAFFIC_HANDLING_MODE_ERROR       0x05
 294 #define UNEXPECTED_MESSAGE_ERROR                      0x06
 295 #define PROTOCOL_ERROR                                0x07
 296 #define UNSUPPORTED_INTERFACE_IDENTIFIER_TYPE_ERROR   0x08
 297 #define INVALID_STREAM_IDENTIFIER_ERROR               0x09
 298 #define UNASSIGNED_TEI_ERROR                          0x0a
 299 #define UNRECOGNIZED_SAPI_ERROR                       0x0b
 300 #define INVALID_TEI_SAPI_COMBINATION_ERROR            0x0c
 301 #define REFUSED_MANAGEMENT_BLOCKING_ERROR             0x0d
 302 #define ASP_IDENTIFIER_REQUIRED_ERROR                 0x0e
 303 #define INVALID_ASP_IDENTIFIER_ERROR                  0x0f
 304
 305 static const value_string error_code_values[] = {
 306   { INVALID_VERSION_ERROR,                       "Invalid version" },
 307   { INVALID_INTERFACE_IDENTIFIER_ERROR,          "Invalid interface identifier" },
 308   { UNSUPPORTED_MESSAGE_CLASS_ERROR,             "Unsupported message class" },
 309   { UNSUPPORTED_MESSAGE_TYPE_ERROR,              "Unsupported message type" },
 310   { UNSUPPORTED_TRAFFIC_HANDLING_MODE_ERROR,     "Unsupported traffic handling mode" },
 311   { UNEXPECTED_MESSAGE_ERROR,                    "Unexpected message" },
 312   { PROTOCOL_ERROR,                              "Protocol error" },
 313   { UNSUPPORTED_INTERFACE_IDENTIFIER_TYPE_ERROR, "Unsupported interface identifier type" },
 314   { INVALID_STREAM_IDENTIFIER_ERROR,             "Invalid stream identifier" },
 315   { UNASSIGNED_TEI_ERROR,                        "Unassigned TEI" },
 316   { UNRECOGNIZED_SAPI_ERROR,                     "Unrecognized SAPI" },
 317   { INVALID_TEI_SAPI_COMBINATION_ERROR,          "Invalid TEI/SAPI combination" },
 318   { 0,                                           NULL } };
 319
 320 static const value_string error_code_ig_values[] = {
 321   { INVALID_VERSION_ERROR,                       "Invalid version" },
 322   { INVALID_INTERFACE_IDENTIFIER_ERROR,          "Invalid interface identifier" },
 323   { UNSUPPORTED_MESSAGE_CLASS_ERROR,             "Unsupported message class" },
 324   { UNSUPPORTED_MESSAGE_TYPE_ERROR,              "Unsupported message type" },
 325   { UNSUPPORTED_TRAFFIC_HANDLING_MODE_ERROR,     "Unsupported traffic handling mode" },
 326   { UNEXPECTED_MESSAGE_ERROR,                    "Unexpected message" },
 327   { PROTOCOL_ERROR,                              "Protocol error" },
 328   { UNSUPPORTED_INTERFACE_IDENTIFIER_TYPE_ERROR, "Unsupported interface identifier type" },
 329   { INVALID_STREAM_IDENTIFIER_ERROR,             "Invalid stream identifier" },
 330   { UNASSIGNED_TEI_ERROR,                        "Unassigned TEI" },
 331   { UNRECOGNIZED_SAPI_ERROR,                     "Unrecognized SAPI" },
 332   { INVALID_TEI_SAPI_COMBINATION_ERROR,          "Invalid TEI/SAPI combination" },
 333   { REFUSED_MANAGEMENT_BLOCKING_ERROR,           "Refused - Management blocking" },
 334   { ASP_IDENTIFIER_REQUIRED_ERROR,               "ASP identifier required" },
 335   { INVALID_ASP_IDENTIFIER_ERROR,                "Invalid ASP identifier" },
 336   { 0,                                           NULL } };
 337
 338 #define ERROR_CODE_LENGTH 4
 339 #define ERROR_CODE_OFFSET PARAMETER_VALUE_OFFSET
 340
 341 static void
 342 dissect_error_code_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 343 {
 344   proto_tree_add_item(parameter_tree, support_IG?hf_error_code_ig:hf_error_code, parameter_tvb, ERROR_CODE_OFFSET, ERROR_CODE_LENGTH, ENC_BIG_ENDIAN);
 345   proto_item_append_text(parameter_item, " (%s)",
 346                          val_to_str_const(tvb_get_ntohl(parameter_tvb, ERROR_CODE_OFFSET), support_IG?error_code_ig_values:error_code_values, "unknown"));
 347 }
 348
 349 #define ASP_STATE_CHANGE_STATUS_TYPE  0x01
 350 #define OTHER_STATUS_TYPE             0x02
 351
 352 static const value_string status_type_values[] = {
 353   { ASP_STATE_CHANGE_STATUS_TYPE,        "Application server state change" },
 354   { OTHER_STATUS_TYPE,                   "Other" },
 355   { 0,                                   NULL } };
 356
 357 #define AS_DOWN_STATUS_IDENT          0x01
 358 #define AS_INACTIVE_STATUS_IDENT      0x02
 359 #define AS_ACTIVE_STATUS_IDENT        0x03
 360 #define AS_PENDING_STATUS_IDENT       0x04
 361
 362 #define INSUFFICIENT_ASP_RESOURCES_STATUS_IDENT 0x01
 363 #define ALTERNATE_ASP_ACTIVE_STATUS_IDENT       0x02
 364
 365 static const value_string status_type_id_values[] = {
 366   { ASP_STATE_CHANGE_STATUS_TYPE * 256 * 256 + AS_DOWN_STATUS_IDENT,         "Application server down" },
 367   { ASP_STATE_CHANGE_STATUS_TYPE * 256 * 256 + AS_INACTIVE_STATUS_IDENT,     "Application server inactive" },
 368   { ASP_STATE_CHANGE_STATUS_TYPE * 256 * 256 + AS_ACTIVE_STATUS_IDENT,       "Application server active" },
 369   { ASP_STATE_CHANGE_STATUS_TYPE * 256 * 256 + AS_PENDING_STATUS_IDENT,      "Application server pending" },
 370   { OTHER_STATUS_TYPE * 256 * 256 + INSUFFICIENT_ASP_RESOURCES_STATUS_IDENT, "Insufficient ASP resources active in AS" },
 371   { OTHER_STATUS_TYPE * 256 * 256 + ALTERNATE_ASP_ACTIVE_STATUS_IDENT,       "Alternate ASP active" },
 372   { 0,                                           NULL } };
 373
 374 static const value_string status_type_id_ig_values[] = {
 375   { ASP_STATE_CHANGE_STATUS_TYPE * 256 * 256 + AS_INACTIVE_STATUS_IDENT,     "Application server inactive" },
 376   { ASP_STATE_CHANGE_STATUS_TYPE * 256 * 256 + AS_ACTIVE_STATUS_IDENT,       "Application server active" },
 377   { ASP_STATE_CHANGE_STATUS_TYPE * 256 * 256 + AS_PENDING_STATUS_IDENT,      "Application server pending" },
 378   { OTHER_STATUS_TYPE * 256 * 256 + INSUFFICIENT_ASP_RESOURCES_STATUS_IDENT, "Insufficient ASP resources active in AS" },
 379   { OTHER_STATUS_TYPE * 256 * 256 + ALTERNATE_ASP_ACTIVE_STATUS_IDENT,       "Alternate ASP active" },
 380   { 0,                                           NULL } };
 381
 382 #define STATUS_TYPE_LENGTH  2
 383 #define STATUS_IDENT_LENGTH 2
 384 #define STATUS_TYPE_OFFSET  PARAMETER_VALUE_OFFSET
 385 #define STATUS_IDENT_OFFSET (STATUS_TYPE_OFFSET + STATUS_TYPE_LENGTH)
 386
 387 static void
 388 dissect_status_type_identification_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 389 {
 390   guint16 status_type, status_id;
 391
 392   status_type = tvb_get_ntohs(parameter_tvb, STATUS_TYPE_OFFSET);
 393   status_id   = tvb_get_ntohs(parameter_tvb, STATUS_IDENT_OFFSET);
 394
 395   proto_tree_add_item(parameter_tree, hf_status_type, parameter_tvb, STATUS_TYPE_OFFSET, STATUS_TYPE_LENGTH, ENC_BIG_ENDIAN);
 396   proto_tree_add_uint_format_value(parameter_tree, hf_status_id,  parameter_tvb, STATUS_IDENT_OFFSET, STATUS_IDENT_LENGTH,
 397                              status_id, "%u (%s)", status_id,
 398                              val_to_str_const(status_type * 256 * 256 + status_id, support_IG?status_type_id_ig_values:status_type_id_values, "unknown"));
 399
 400   proto_item_append_text(parameter_item, " (%s)",
 401                          val_to_str_const(status_type * 256 * 256 + status_id, support_IG?status_type_id_ig_values:status_type_id_values, "unknown status information"));
 402 }
 403
 404 #define PROTOCOL_DATA_OFFSET PARAMETER_VALUE_OFFSET
 405
 406 static void
 407 dissect_protocol_data_parameter(tvbuff_t *parameter_tvb, proto_item *parameter_item, packet_info *pinfo, proto_tree *tree)
 408 {
 409   guint16 protocol_data_length;
 410   tvbuff_t *protocol_data_tvb;
 411
 412   protocol_data_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH;
 413   protocol_data_tvb    = tvb_new_subset_length(parameter_tvb, PROTOCOL_DATA_OFFSET, protocol_data_length);
 414   proto_item_append_text(parameter_item, " (%u byte%s)", protocol_data_length, plurality(protocol_data_length, "", "s"));
 415
 416   if(sapi_val_assigned == FALSE)
 417   {
 418     return;
 419   }
 420   if(global_iua_gsm_sapis) {
 421     if (!dissector_try_uint(lapd_gsm_sapi_dissector_table, sapi_val, protocol_data_tvb, pinfo, tree))
 422       call_data_dissector(protocol_data_tvb, pinfo, tree);
 423     return;
 424   }
 425
 426   switch(sapi_val)
 427   {
 428     case SAPI_VAL_CALL_CONTROL:
 429     case SAPI_VAL_Q931_PACKET:
 430       call_dissector(q931_handle, protocol_data_tvb, pinfo, tree);
 431       break;
 432
 433     case SAPI_VAL_X25:
 434       call_dissector(x25_handle, protocol_data_tvb, pinfo, tree);
 435       break;
 436
 437     default:
 438       break;
 439   }
 440 }
 441
 442 #define RELEASE_MGMT_REASON   0
 443 #define RELEASE_PHYS_REASON   1
 444 #define RELEASE_DM_REASON     2
 445 #define RELEASE_OTHER_REASON  3
 446
 447 static const value_string release_reason_values[] = {
 448   { RELEASE_MGMT_REASON,  "Management layer generated release" },
 449   { RELEASE_PHYS_REASON,  "Physical layer alarm generated release" },
 450   { RELEASE_DM_REASON,    "Layer 2 should release" },
 451   { RELEASE_OTHER_REASON, "Other reason" },
 452   { 0,                    NULL } };
 453
 454 #define RELEASE_REASON_OFFSET PARAMETER_VALUE_OFFSET
 455 #define RELEASE_REASON_LENGTH 4
 456
 457 static void
 458 dissect_release_reason_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 459 {
 460   proto_tree_add_item(parameter_tree, hf_release_reason, parameter_tvb, RELEASE_REASON_OFFSET, RELEASE_REASON_LENGTH, ENC_BIG_ENDIAN);
 461   proto_item_append_text(parameter_item, " (%s)",
 462                          val_to_str_const(tvb_get_ntohl(parameter_tvb, RELEASE_REASON_OFFSET), release_reason_values, "unknown"));
 463 }
 464
 465 #define TEI_STATUS_ASSIGNED       0
 466 #define TEI_STATUS_UNASSIGNED     1
 467
 468 static const value_string tei_status_values[] = {
 469   { TEI_STATUS_ASSIGNED,   "TEI is considered assigned by Q.921" },
 470   { TEI_STATUS_UNASSIGNED, "TEI is considered unassigned by Q.921" },
 471   { 0,                    NULL } };
 472
 473 #define TEI_STATUS_LENGTH 4
 474 #define TEI_STATUS_OFFSET PARAMETER_VALUE_OFFSET
 475
 476 static void
 477 dissect_tei_status_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 478 {
 479   proto_tree_add_item(parameter_tree, hf_tei_status, parameter_tvb, TEI_STATUS_OFFSET, TEI_STATUS_LENGTH, ENC_BIG_ENDIAN);
 480   proto_item_append_text(parameter_item, " (%s)",
 481                       val_to_str_const(tvb_get_ntohl(parameter_tvb, TEI_STATUS_OFFSET), tei_status_values, "unknown"));
 482 }
 483
 484 #define ASP_ID_LENGTH 4
 485 #define ASP_ID_OFFSET PARAMETER_VALUE_OFFSET
 486
 487 static void
 488 dissect_asp_identifier_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 489 {
 490   proto_tree_add_item(parameter_tree, hf_asp_id, parameter_tvb, ASP_ID_OFFSET, ASP_ID_LENGTH, ENC_BIG_ENDIAN);
 491   proto_item_append_text(parameter_item, " (%u)", tvb_get_ntohl(parameter_tvb, ASP_ID_OFFSET));
 492 }
 493
 494 static void
 495 dissect_unknown_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 496 {
 497   guint16 parameter_value_length;
 498
 499   parameter_value_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH;
 500   if (parameter_value_length > 0)
 501     proto_tree_add_item(parameter_tree, hf_parameter_value, parameter_tvb, PARAMETER_VALUE_OFFSET, parameter_value_length, ENC_NA);
 502   proto_item_append_text(parameter_item, " with tag %u and %u byte%s value",
 503                          tvb_get_ntohs(parameter_tvb, PARAMETER_TAG_OFFSET), parameter_value_length, plurality(parameter_value_length, "", "s"));
 504 }
 505
 506 #define INT_INTERFACE_IDENTIFIER_PARAMETER_TAG           0x01
 507 #define TEXT_INTERFACE_IDENTIFIER_PARAMETER_TAG          0x03
 508 #define INFO_PARAMETER_TAG                               0x04
 509 #define DLCI_PARAMETER_TAG                               0x05
 510 #define DIAGNOSTIC_INFORMATION_PARAMETER_TAG             0x07
 511 #define INTEGER_RANGE_INTERFACE_IDENTIFIER_PARAMETER_TAG 0x08
 512 #define HEARTBEAT_DATA_PARAMETER_TAG                     0x09
 513 #define ASP_REASON_PARAMETER_TAG                         0x0a
 514 #define TRAFFIC_MODE_TYPE_PARAMETER_TAG                  0x0b
 515 #define ERROR_CODE_PARAMETER_TAG                         0x0c
 516 #define STATUS_TYPE_INDENTIFICATION_PARAMETER_TAG        0x0d
 517 #define PROTOCOL_DATA_PARAMETER_TAG                      0x0e
 518 #define RELEASE_REASON_PARAMETER_TAG                     0x0f
 519 #define TEI_STATUS_PARAMETER_TAG                         0x10
 520 #define ASP_IDENTIFIER_PARAMETER_TAG                     0x11
 521
 522 static const value_string parameter_tag_values[] = {
 523   { INT_INTERFACE_IDENTIFIER_PARAMETER_TAG,                "Integer interface identifier" },
 524   { TEXT_INTERFACE_IDENTIFIER_PARAMETER_TAG,               "Text interface identifier" },
 525   { INFO_PARAMETER_TAG,                                    "Info" },
 526   { DLCI_PARAMETER_TAG,                                    "DLCI" },
 527   { DIAGNOSTIC_INFORMATION_PARAMETER_TAG,                  "Diagnostic information" },
 528   { INTEGER_RANGE_INTERFACE_IDENTIFIER_PARAMETER_TAG,      "Integer range interface identifier" },
 529   { HEARTBEAT_DATA_PARAMETER_TAG,                          "Heartbeat data" },
 530   { ASP_REASON_PARAMETER_TAG,                              "Reason" },
 531   { TRAFFIC_MODE_TYPE_PARAMETER_TAG,                       "Traffic mode type" },
 532   { ERROR_CODE_PARAMETER_TAG,                              "Error code" },
 533   { STATUS_TYPE_INDENTIFICATION_PARAMETER_TAG,             "Status type/identification" },
 534   { PROTOCOL_DATA_PARAMETER_TAG,                           "Protocol data" },
 535   { RELEASE_REASON_PARAMETER_TAG,                          "Reason" },
 536   { TEI_STATUS_PARAMETER_TAG,                              "TEI status" },
 537   { 0,                           NULL } };
 538
 539 static const value_string parameter_tag_ig_values[] = {
 540   { INT_INTERFACE_IDENTIFIER_PARAMETER_TAG,                "Integer interface identifier" },
 541   { TEXT_INTERFACE_IDENTIFIER_PARAMETER_TAG,               "Text interface identifier" },
 542   { INFO_PARAMETER_TAG,                                    "Info" },
 543   { DLCI_PARAMETER_TAG,                                    "DLCI" },
 544   { DIAGNOSTIC_INFORMATION_PARAMETER_TAG,                  "Diagnostic information" },
 545   { INTEGER_RANGE_INTERFACE_IDENTIFIER_PARAMETER_TAG,      "Integer range interface identifier" },
 546   { HEARTBEAT_DATA_PARAMETER_TAG,                          "Heartbeat data" },
 547   { TRAFFIC_MODE_TYPE_PARAMETER_TAG,                       "Traffic mode type" },
 548   { ERROR_CODE_PARAMETER_TAG,                              "Error code" },
 549   { STATUS_TYPE_INDENTIFICATION_PARAMETER_TAG,             "Status type/identification" },
 550   { PROTOCOL_DATA_PARAMETER_TAG,                           "Protocol data" },
 551   { RELEASE_REASON_PARAMETER_TAG,                          "Reason" },
 552   { TEI_STATUS_PARAMETER_TAG,                              "TEI status" },
 553   { ASP_IDENTIFIER_PARAMETER_TAG,                          "ASP identifier"},
 554   { 0,                           NULL } };
 555
 556 static void
 557 dissect_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *tree, proto_tree *iua_tree)
 558 {
 559   guint16 tag, length, padding_length;
 560   proto_item *parameter_item;
 561   proto_tree *parameter_tree;
 562
 563   /* extract tag and length from the parameter */
 564   tag            = tvb_get_ntohs(parameter_tvb, PARAMETER_TAG_OFFSET);
 565   length         = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET);
 566   padding_length = tvb_reported_length(parameter_tvb) - length;
 567
 568   /* create proto_tree stuff */
 569   parameter_tree   = proto_tree_add_subtree_format(iua_tree, parameter_tvb, PARAMETER_HEADER_OFFSET, -1, ett_iua_parameter, &parameter_item,
 570                                          "%s parameter", val_to_str_const(tag, support_IG?parameter_tag_ig_values:parameter_tag_values, "Unknown"));
 571
 572   /* add tag and length to the iua tree */
 573   proto_tree_add_item(parameter_tree, support_IG?hf_parameter_tag_ig:hf_parameter_tag, parameter_tvb, PARAMETER_TAG_OFFSET, PARAMETER_TAG_LENGTH, ENC_BIG_ENDIAN);
 574   proto_tree_add_item(parameter_tree, hf_parameter_length, parameter_tvb, PARAMETER_LENGTH_OFFSET, PARAMETER_LENGTH_LENGTH, ENC_BIG_ENDIAN);
 575
 576   switch(tag) {
 577   case INT_INTERFACE_IDENTIFIER_PARAMETER_TAG:
 578     dissect_int_interface_identifier_parameter(parameter_tvb, parameter_tree, parameter_item);
 579     break;
 580   case TEXT_INTERFACE_IDENTIFIER_PARAMETER_TAG:
 581     dissect_text_interface_identifier_parameter(parameter_tvb, parameter_tree, parameter_item);
 582     break;
 583   case INFO_PARAMETER_TAG:
 584     dissect_info_string_parameter(parameter_tvb, parameter_tree, parameter_item);
 585     break;
 586   case DLCI_PARAMETER_TAG:
 587     dissect_dlci_parameter(parameter_tvb, parameter_tree);
 588     break;
 589   case DIAGNOSTIC_INFORMATION_PARAMETER_TAG:
 590     dissect_diagnostic_information_parameter(parameter_tvb, parameter_tree, parameter_item);
 591     break;
 592   case INTEGER_RANGE_INTERFACE_IDENTIFIER_PARAMETER_TAG:
 593     dissect_integer_range_interface_identifier_parameter(parameter_tvb, parameter_tree, parameter_item);
 594     break;
 595   case HEARTBEAT_DATA_PARAMETER_TAG:
 596     dissect_heartbeat_data_parameter(parameter_tvb, parameter_tree, parameter_item);
 597     break;
 598   case ASP_REASON_PARAMETER_TAG:
 599     if (support_IG)
 600       dissect_unknown_parameter(parameter_tvb, parameter_tree, parameter_item);
 601     else
 602       dissect_asp_reason_parameter(parameter_tvb, parameter_tree, parameter_item);
 603     break;
 604   case TRAFFIC_MODE_TYPE_PARAMETER_TAG:
 605     dissect_traffic_mode_type_parameter(parameter_tvb, parameter_tree, parameter_item);
 606     break;
 607   case ERROR_CODE_PARAMETER_TAG:
 608     dissect_error_code_parameter(parameter_tvb, parameter_tree, parameter_item);
 609     break;
 610   case STATUS_TYPE_INDENTIFICATION_PARAMETER_TAG:
 611     dissect_status_type_identification_parameter(parameter_tvb, parameter_tree, parameter_item);
 612     break;
 613   case PROTOCOL_DATA_PARAMETER_TAG:
 614     dissect_protocol_data_parameter(parameter_tvb, parameter_item, pinfo, tree);
 615     break;
 616   case RELEASE_REASON_PARAMETER_TAG:
 617     dissect_release_reason_parameter(parameter_tvb, parameter_tree, parameter_item);
 618     break;
 619   case TEI_STATUS_PARAMETER_TAG:
 620     dissect_tei_status_parameter(parameter_tvb, parameter_tree, parameter_item);
 621     break;
 622   case ASP_IDENTIFIER_PARAMETER_TAG:
 623     if (support_IG)
 624       dissect_asp_identifier_parameter(parameter_tvb, parameter_tree, parameter_item);
 625     else
 626       dissect_unknown_parameter(parameter_tvb, parameter_tree, parameter_item);
 627     break;
 628   default:
 629     dissect_unknown_parameter(parameter_tvb, parameter_tree, parameter_item);
 630     break;
 631   };
 632
 633   if (padding_length > 0)
 634     proto_tree_add_item(parameter_tree, hf_parameter_padding, parameter_tvb, PARAMETER_HEADER_OFFSET + length, padding_length, ENC_NA);
 635 }
 636
 637 static void
 638 dissect_parameters(tvbuff_t *parameters_tvb, packet_info *pinfo, proto_tree *tree, proto_tree *iua_tree)
 639 {
 640   gint offset, length, total_length, remaining_length;
 641   tvbuff_t *parameter_tvb;
 642
 643   offset = 0;
 644   while((remaining_length = tvb_reported_length_remaining(parameters_tvb, offset))) {
 645     length       = tvb_get_ntohs(parameters_tvb, offset + PARAMETER_LENGTH_OFFSET);
 646     total_length = ADD_PADDING(length);
 647     if (remaining_length >= length)
 648       total_length = MIN(total_length, remaining_length);
 649     /* create a tvb for the parameter including the padding bytes */
 650     parameter_tvb  = tvb_new_subset_length(parameters_tvb, offset, total_length);
 651     dissect_parameter(parameter_tvb, pinfo, tree, iua_tree);
 652     /* get rid of the handled parameter */
 653     offset += total_length;
 654   }
 655 }
 656
 657 #define VERSION_LENGTH         1
 658 #define RESERVED_LENGTH        1
 659 #define MESSAGE_CLASS_LENGTH   1
 660 #define MESSAGE_TYPE_LENGTH    1
 661 #define MESSAGE_LENGTH_LENGTH  4
 662 #define COMMON_HEADER_LENGTH   (VERSION_LENGTH + RESERVED_LENGTH + MESSAGE_CLASS_LENGTH + \
 663                                 MESSAGE_TYPE_LENGTH + MESSAGE_LENGTH_LENGTH)
 664
 665 #define COMMON_HEADER_OFFSET   0
 666 #define VERSION_OFFSET         COMMON_HEADER_OFFSET
 667 #define RESERVED_OFFSET        (VERSION_OFFSET + VERSION_LENGTH)
 668 #define MESSAGE_CLASS_OFFSET   (RESERVED_OFFSET + RESERVED_LENGTH)
 669 #define MESSAGE_TYPE_OFFSET    (MESSAGE_CLASS_OFFSET + MESSAGE_CLASS_LENGTH)
 670 #define MESSAGE_LENGTH_OFFSET  (MESSAGE_TYPE_OFFSET + MESSAGE_TYPE_LENGTH)
 671 #define PARAMETERS_OFFSET      (COMMON_HEADER_OFFSET + COMMON_HEADER_LENGTH)
 672
 673 #define PROTOCOL_VERSION_RELEASE_1             1
 674
 675 static const value_string protocol_version_values[] = {
 676   { PROTOCOL_VERSION_RELEASE_1,  "Release 1" },
 677   { 0,                           NULL } };
 678
 679 #define MESSAGE_CLASS_MGMT_MESSAGE        0
 680 #define MESSAGE_CLASS_TFER_MESSAGE        1
 681 #define MESSAGE_CLASS_SSNM_MESSAGE        2
 682 #define MESSAGE_CLASS_ASPSM_MESSAGE       3
 683 #define MESSAGE_CLASS_ASPTM_MESSAGE       4
 684 #define MESSAGE_CLASS_QPTM_MESSAGE        5
 685 #define MESSAGE_CLASS_MAUP_MESSAGE        6
 686 #define MESSAGE_CLASS_CL_SUA_MESSAGE      7
 687 #define MESSAGE_CLASS_CO_SUA_MESSAGE      8
 688
 689 static const value_string message_class_values[] = {
 690   { MESSAGE_CLASS_MGMT_MESSAGE,   "Management messages" },
 691   { MESSAGE_CLASS_TFER_MESSAGE,   "Transfer messages" },
 692   { MESSAGE_CLASS_SSNM_MESSAGE,   "SS7 signalling network management messages" },
 693   { MESSAGE_CLASS_ASPSM_MESSAGE,  "ASP state maintenance messages" },
 694   { MESSAGE_CLASS_ASPTM_MESSAGE,  "ASP traffic maintenance messages" },
 695   { MESSAGE_CLASS_QPTM_MESSAGE,   "Q.921/Q.931 boundary primitive transport messages" },
 696   { MESSAGE_CLASS_MAUP_MESSAGE,   "MTP2 user adaptation messages" },
 697   { MESSAGE_CLASS_CL_SUA_MESSAGE, "Connectionless messages (SUA)" },
 698   { MESSAGE_CLASS_CO_SUA_MESSAGE, "Connection-oriented messages (SUA)" },
 699   { 0,                             NULL } };
 700
 701 /* message types for MGMT messages */
 702 #define MESSAGE_TYPE_ERR                  0
 703 #define MESSAGE_TYPE_NTFY                 1
 704 #define MESSAGE_TYPE_TEI_STATUS_REQ       2
 705 #define MESSAGE_TYPE_TEI_STATUS_CON       3
 706 #define MESSAGE_TYPE_TEI_STATUS_IND       4
 707 #define MESSAGE_TYPE_TEI_QUERY_REQ        5
 708
 709 /* message types for ASPSM messages */
 710 #define MESSAGE_TYPE_UP                   1
 711 #define MESSAGE_TYPE_DOWN                 2
 712 #define MESSAGE_TYPE_BEAT                 3
 713 #define MESSAGE_TYPE_UP_ACK               4
 714 #define MESSAGE_TYPE_DOWN_ACK             5
 715 #define MESSAGE_TYPE_BEAT_ACK             6
 716
 717 /* message types for ASPTM messages */
 718 #define MESSAGE_TYPE_ACTIVE               1
 719 #define MESSAGE_TYPE_INACTIVE             2
 720 #define MESSAGE_TYPE_ACTIVE_ACK           3
 721 #define MESSAGE_TYPE_INACTIVE_ACK         4
 722
 723 /* message types for QPTM messages */
 724 #define MESSAGE_TYPE_DATA_REQUEST         1
 725 #define MESSAGE_TYPE_DATA_INDICATION      2
 726 #define MESSAGE_TYPE_UNIT_DATA_REQUEST    3
 727 #define MESSAGE_TYPE_UNIT_DATA_INDICATION 4
 728 #define MESSAGE_TYPE_ESTABLISH_REQUEST    5
 729 #define MESSAGE_TYPE_ESTABLISH_CONFIRM    6
 730 #define MESSAGE_TYPE_ESTABLISH_INDICATION 7
 731 #define MESSAGE_TYPE_RELEASE_REQUEST      8
 732 #define MESSAGE_TYPE_RELEASE_CONFIRM      9
 733 #define MESSAGE_TYPE_RELEASE_INDICATION  10
 734
 735
 736 static const value_string message_class_type_values[] = {
 737   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_ERR,                  "Error" },
 738   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_NTFY,                 "Notify" },
 739   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_REQ,       "TEI status request" },
 740   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_CON,       "TEI status confirmation" },
 741   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_IND,       "TEI status indication" },
 742   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_UP,                   "ASP up" },
 743   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_DOWN,                 "ASP down" },
 744   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_BEAT,                 "Heartbeat" },
 745   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_UP_ACK,               "ASP up ack" },
 746   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_DOWN_ACK,             "ASP down ack" },
 747   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_BEAT_ACK,             "Heartbeat ack" },
 748   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_ACTIVE ,              "ASP active" },
 749   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_INACTIVE ,            "ASP inactive" },
 750   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_ACTIVE_ACK ,          "ASP active ack" },
 751   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_INACTIVE_ACK ,        "ASP inactive ack" },
 752   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_DATA_REQUEST,         "Data request" },
 753   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_DATA_INDICATION,      "Data indication" },
 754   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_UNIT_DATA_REQUEST,    "Unit data request" },
 755   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_UNIT_DATA_INDICATION, "Unit data indication" },
 756   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_REQUEST,    "Establish request" },
 757   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_CONFIRM,    "Establish confirmation" },
 758   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_INDICATION, "Establish indication" },
 759   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_REQUEST,      "Release request" },
 760   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_CONFIRM,      "Release confirmation" },
 761   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_INDICATION,   "Release indication" },
 762   { 0,                                                                     NULL } };
 763
 764 static const value_string message_class_type_ig_values[] = {
 765   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_ERR,                  "Error" },
 766   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_NTFY,                 "Notify" },
 767   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_REQ,       "TEI status request" },
 768   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_CON,       "TEI status confirmation" },
 769   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_IND,       "TEI status indication" },
 770   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_QUERY_REQ,        "TEI query request" },
 771   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_UP,                   "ASP up" },
 772   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_DOWN,                 "ASP down" },
 773   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_BEAT,                 "Heartbeat" },
 774   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_UP_ACK,               "ASP up ack" },
 775   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_DOWN_ACK,             "ASP down ack" },
 776   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_BEAT_ACK,             "Heartbeat ack" },
 777   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_ACTIVE ,              "ASP active" },
 778   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_INACTIVE ,            "ASP inactive" },
 779   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_ACTIVE_ACK ,          "ASP active ack" },
 780   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_INACTIVE_ACK ,        "ASP inactive ack" },
 781   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_DATA_REQUEST,         "Data request" },
 782   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_DATA_INDICATION,      "Data indication" },
 783   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_UNIT_DATA_REQUEST,    "Unit data request" },
 784   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_UNIT_DATA_INDICATION, "Unit data indication" },
 785   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_REQUEST,    "Establish request" },
 786   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_CONFIRM,    "Establish confirmation" },
 787   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_INDICATION, "Establish indication" },
 788   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_REQUEST,      "Release request" },
 789   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_CONFIRM,      "Release confirmation" },
 790   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_INDICATION,   "Release indication" },
 791   { 0,                                                                     NULL } };
 792
 793 static const value_string message_class_type_acro_values[] = {
 794   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_ERR,                  "ERR" },
 795   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_NTFY,                 "NTFY" },
 796   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_REQ,       "TEI_STAT_REQ" },
 797   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_CON,       "TEI_STAT_CON" },
 798   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_IND,       "TEI_STAT_IND" },
 799   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_UP,                   "ASP_UP" },
 800   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_DOWN,                 "ASP_DOWN" },
 801   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_BEAT,                 "BEAT" },
 802   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_UP_ACK,               "ASP_UP_ACK" },
 803   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_DOWN_ACK,             "ASP_DOWN_ACK" },
 804   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_BEAT_ACK,             "BEAT_ACK" },
 805   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_ACTIVE ,              "ASP_ACTIVE" },
 806   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_INACTIVE ,            "ASP_INACTIVE" },
 807   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_ACTIVE_ACK ,          "ASP_ACTIVE_ACK" },
 808   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_INACTIVE_ACK ,        "ASP_INACTIVE_ACK" },
 809   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_DATA_REQUEST,         "DATA_REQ" },
 810   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_DATA_INDICATION,      "DATA_IND" },
 811   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_UNIT_DATA_REQUEST,    "U_DATA_REQ" },
 812   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_UNIT_DATA_INDICATION, "U_DATA_IND" },
 813   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_REQUEST,    "EST_REQ" },
 814   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_CONFIRM,    "EST_CON" },
 815   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_INDICATION, "EST_IND" },
 816   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_REQUEST,      "REL_REQ" },
 817   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_CONFIRM,      "REL_CON" },
 818   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_INDICATION,   "REL_IND" },
 819   { 0,                                                                     NULL } };
 820
 821 static const value_string message_class_type_acro_ig_values[] = {
 822   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_ERR,                  "ERR" },
 823   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_NTFY,                 "NTFY" },
 824   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_REQ,       "TEI_STAT_REQ" },
 825   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_CON,       "TEI_STAT_CON" },
 826   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_IND,       "TEI_STAT_IND" },
 827   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_QUERY_REQ,        "TEI_QUERY_REQ" },
 828   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_UP,                   "ASP_UP" },
 829   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_DOWN,                 "ASP_DOWN" },
 830   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_BEAT,                 "BEAT" },
 831   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_UP_ACK,               "ASP_UP_ACK" },
 832   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_DOWN_ACK,             "ASP_DOWN_ACK" },
 833   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_BEAT_ACK,             "BEAT_ACK" },
 834   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_ACTIVE ,              "ASP_ACTIVE" },
 835   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_INACTIVE ,            "ASP_INACTIVE" },
 836   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_ACTIVE_ACK ,          "ASP_ACTIVE_ACK" },
 837   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_INACTIVE_ACK ,        "ASP_INACTIVE_ACK" },
 838   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_DATA_REQUEST,         "DATA_REQ" },
 839   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_DATA_INDICATION,      "DATA_IND" },
 840   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_UNIT_DATA_REQUEST,    "U_DATA_REQ" },
 841   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_UNIT_DATA_INDICATION, "U_DATA_IND" },
 842   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_REQUEST,    "EST_REQ" },
 843   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_CONFIRM,    "EST_CON" },
 844   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_INDICATION, "EST_IND" },
 845   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_REQUEST,      "REL_REQ" },
 846   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_CONFIRM,      "REL_CON" },
 847   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_INDICATION,   "REL_IND" },
 848   { 0,                                                                     NULL } };
 849
 850 static void
 851 dissect_common_header(tvbuff_t *common_header_tvb, packet_info *pinfo, proto_tree *iua_tree)
 852 {
 853   guint8 message_class, message_type;
 854
 855   message_class  = tvb_get_guint8(common_header_tvb, MESSAGE_CLASS_OFFSET);
 856   message_type   = tvb_get_guint8(common_header_tvb, MESSAGE_TYPE_OFFSET);
 857
 858   col_add_fstr(pinfo->cinfo, COL_INFO, "%s ", val_to_str_const(message_class * 256 + message_type, support_IG?message_class_type_acro_ig_values:message_class_type_acro_values, "UNKNOWN"));
 859
 860   if (iua_tree) {
 861     /* add the components of the common header to the protocol tree */
 862     proto_tree_add_item(iua_tree, hf_version, common_header_tvb, VERSION_OFFSET, VERSION_LENGTH, ENC_BIG_ENDIAN);
 863     proto_tree_add_item(iua_tree, hf_reserved, common_header_tvb, RESERVED_OFFSET, RESERVED_LENGTH, ENC_BIG_ENDIAN);
 864     proto_tree_add_item(iua_tree, hf_message_class, common_header_tvb, MESSAGE_CLASS_OFFSET, MESSAGE_CLASS_LENGTH, ENC_BIG_ENDIAN);
 865     proto_tree_add_uint_format_value(iua_tree, hf_message_type,
 866                                common_header_tvb, MESSAGE_TYPE_OFFSET, MESSAGE_TYPE_LENGTH,
 867                                message_type, "%u (%s)",
 868                                message_type, val_to_str_const(message_class * 256 + message_type, support_IG?message_class_type_ig_values:message_class_type_values, "reserved"));
 869     proto_tree_add_item(iua_tree, hf_message_length, common_header_tvb, MESSAGE_LENGTH_OFFSET, MESSAGE_LENGTH_LENGTH, ENC_BIG_ENDIAN);
 870   }
 871 }
 872
 873 static void
 874 dissect_iua_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *tree, proto_tree *iua_tree)
 875 {
 876   tvbuff_t *common_header_tvb, *parameters_tvb;
 877
 878   sapi_val_assigned = FALSE;
 879
 880   common_header_tvb = tvb_new_subset_length(message_tvb, COMMON_HEADER_OFFSET, COMMON_HEADER_LENGTH);
 881   parameters_tvb    = tvb_new_subset_remaining(message_tvb, PARAMETERS_OFFSET);
 882   dissect_common_header(common_header_tvb, pinfo, iua_tree);
 883   dissect_parameters(parameters_tvb, pinfo, tree, iua_tree);
 884 }
 885
 886 static int
 887 dissect_iua(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
 888 {
 889   proto_item *iua_item;
 890   proto_tree *iua_tree;
 891
 892   /* make entry in the Protocol column on summary display */
 893
 894   col_set_str(pinfo->cinfo, COL_PROTOCOL, support_IG?"IUA (RFC 3057 + IG)":"IUA (RFC 3057)");
 895
 896   /* create the m3ua protocol tree */
 897   iua_item = proto_tree_add_item(tree, proto_iua, message_tvb, 0, -1, ENC_NA);
 898   iua_tree = proto_item_add_subtree(iua_item, ett_iua);
 899
 900   /* dissect the message */
 901   dissect_iua_message(message_tvb, pinfo, tree, iua_tree);
 902   return tvb_captured_length(message_tvb);
 903 }
 904
 905 /* Register the protocol with Wireshark */
 906 void
 907 proto_register_iua(void)
 908 {
 909
 910   /* Setup list of header fields */
 911   static hf_register_info hf[] = {
 912     { &hf_int_interface_id,      { "Integer interface identifier", "iua.int_interface_identifier",  FT_UINT32,  BASE_HEX,  NULL,                           0x0,            NULL, HFILL } },
 913     { &hf_text_interface_id,     { "Text interface identifier",    "iua.text_interface_identifier", FT_STRING,  BASE_NONE, NULL,                           0x0,            NULL, HFILL } },
 914     { &hf_info_string,           { "Info string",                  "iua.info_string",               FT_STRING,  BASE_NONE, NULL,                           0x0,            NULL, HFILL } },
 915     { &hf_dlci_zero_bit,         { "Zero bit",                     "iua.dlci_zero_bit",             FT_BOOLEAN, 8,         NULL,                           ZERO_BIT_MASK,  NULL, HFILL } },
 916     { &hf_dlci_spare_bit,        { "Spare bit",                    "iua.dlci_spare_bit",            FT_BOOLEAN, 8,         NULL,                           SPARE_BIT_MASK, NULL, HFILL } },
 917     { &hf_dlci_sapi,             { "SAPI",                         "iua.dlci_sapi",                 FT_UINT8,   BASE_HEX,  VALS(sapi_values),              SAPI_MASK,      NULL, HFILL } },
 918     { &hf_dlci_gsm_sapi,             { "SAPI",                     "iua.dlci_gsm_sapi",             FT_UINT8,   BASE_HEX,  VALS(gsm_sapi_vals),            SAPI_MASK,      NULL, HFILL } },
 919     { &hf_dlci_one_bit,          { "One bit",                      "iua.dlci_one_bit",              FT_BOOLEAN, 8,         NULL,                           ONE_BIT_MASK,   NULL, HFILL } },
 920     { &hf_dlci_tei,              { "TEI",                          "iua.dlci_tei",                  FT_UINT8,   BASE_HEX,  NULL,                           TEI_MASK,       NULL, HFILL } },
 921     { &hf_dlci_spare,            { "Spare",                        "iua.dlci_spare",                FT_UINT16,  BASE_HEX,  NULL,                           0x0,            NULL, HFILL } },
 922     { &hf_diag_info,             { "Diagnostic information",       "iua.diagnostic_information",    FT_BYTES,   BASE_NONE, NULL,                           0x0,            NULL, HFILL } },
 923     { &hf_interface_range_start, { "Start",                        "iua.interface_range_start",     FT_UINT32,  BASE_DEC,  NULL,                           0x0,            NULL, HFILL } },
 924     { &hf_interface_range_end,   { "End",                          "iua.interface_range_end",       FT_UINT32,  BASE_DEC,  NULL,                           0x0,            NULL, HFILL } },
 925     { &hf_heartbeat_data,        { "Heartbeat data",               "iua.heartbeat_data",            FT_BYTES,   BASE_NONE, NULL,                           0x0,            NULL, HFILL } },
 926     { &hf_asp_reason,            { "Reason",                       "iua.asp_reason",                FT_UINT32,  BASE_HEX,  VALS(asp_reason_values),        0x0,            NULL, HFILL } },
 927     { &hf_traffic_mode_type,     { "Traffic mode type",            "iua.traffic_mode_type",         FT_UINT32,  BASE_HEX,  VALS(traffic_mode_type_values), 0x0,            NULL, HFILL } },
 928     { &hf_error_code,            { "Error code",                   "iua.error_code",                FT_UINT32,  BASE_DEC,  VALS(error_code_values),        0x0,            NULL, HFILL } },
 929     { &hf_error_code_ig,         { "Error code",                   "iua.error_code",                FT_UINT32,  BASE_DEC,  VALS(error_code_ig_values),     0x0,            NULL, HFILL } },
 930     { &hf_status_type,           { "Status type",                  "iua.status_type",               FT_UINT16,  BASE_DEC,  VALS(status_type_values),       0x0,            NULL, HFILL } },
 931     { &hf_status_id,             { "Status identification",        "iua.status_identification",     FT_UINT16,  BASE_DEC,  NULL,                           0x0,            NULL, HFILL } },
 932     { &hf_release_reason,        { "Reason",                       "iua.release_reason",            FT_UINT32,  BASE_HEX,  VALS(release_reason_values),    0x0,            NULL, HFILL } },
 933     { &hf_tei_status,            { "TEI status",                   "iua.tei_status",                FT_UINT32,  BASE_HEX,  VALS(tei_status_values),        0x0,            NULL, HFILL } },
 934     { &hf_asp_id,                { "ASP identifier",               "iua.asp_identifier",            FT_UINT32,  BASE_HEX,  NULL,                           0x0,            NULL, HFILL } },
 935     { &hf_parameter_tag,         { "Parameter Tag",                "iua.parameter_tag",             FT_UINT16,  BASE_DEC,  VALS(parameter_tag_values),     0x0,            NULL, HFILL } },
 936     { &hf_parameter_tag_ig,      { "Parameter Tag",                "iua.parameter_tag",             FT_UINT16,  BASE_DEC,  VALS(parameter_tag_ig_values),  0x0,            NULL, HFILL } },
 937     { &hf_parameter_length,      { "Parameter length",             "iua.parameter_length",          FT_UINT16,  BASE_DEC,  NULL,                           0x0,            NULL, HFILL } },
 938     { &hf_parameter_value,       { "Parameter value",              "iua.parameter_value",           FT_BYTES,   BASE_NONE, NULL,                           0x0,            NULL, HFILL } },
 939     { &hf_parameter_padding,     { "Parameter padding",            "iua.parameter_padding",         FT_BYTES,   BASE_NONE, NULL,                           0x0,            NULL, HFILL } },
 940     { &hf_version,               { "Version",                      "iua.version",                   FT_UINT8,   BASE_DEC,  VALS(protocol_version_values),  0x0,            NULL, HFILL } },
 941     { &hf_reserved,              { "Reserved",                     "iua.reserved",                  FT_UINT8,   BASE_HEX,  NULL,                           0x0,            NULL, HFILL } },
 942     { &hf_message_class,         { "Message class",                "iua.message_class",             FT_UINT8,   BASE_DEC,  VALS(message_class_values),     0x0,            NULL, HFILL } },
 943     { &hf_message_type,          { "Message Type",                 "iua.message_type",              FT_UINT8,   BASE_DEC,  NULL,                           0x0,            NULL, HFILL } },
 944     { &hf_message_length,        { "Message length",               "iua.message_length",            FT_UINT32,  BASE_DEC,  NULL,                           0x0,            NULL, HFILL } },
 945    };
 946   /* Setup protocol subtree array */
 947   static gint *ett[] = {
 948     &ett_iua,
 949     &ett_iua_parameter,
 950   };
 951
 952   /* Register the protocol name and description */
 953   proto_iua = proto_register_protocol("ISDN Q.921-User Adaptation Layer", "IUA", "iua");
 954   iua_module = prefs_register_protocol(proto_iua, NULL);
 955
 956   /* Required function calls to register the header fields and subtrees used */
 957   proto_register_field_array(proto_iua, hf, array_length(hf));
 958   proto_register_subtree_array(ett, array_length(ett));
 959   prefs_register_bool_preference(iua_module, "support_ig", "Support Implementers Guide", "Support Implementers Guide (version 01)", &support_IG);
 960
 961   prefs_register_bool_preference(iua_module, "use_gsm_sapi_values",
 962         "Use GSM SAPI values",
 963         "Use SAPI values as specified in TS 48 056",
 964         &global_iua_gsm_sapis);
 965
 966   /* Allow other dissectors to find this one by name. */
 967   iua_handle = register_dissector("iua", dissect_iua, proto_iua);
 968 }
 969
 970 #define SCTP_PORT_IUA          9900
 971
 972 void
 973 proto_reg_handoff_iua(void)
 974 {
 975   q931_handle = find_dissector_add_dependency("q931", proto_iua);
 976   x25_handle  = find_dissector_add_dependency("x.25", proto_iua);
 977
 978   dissector_add_uint("sctp.port", SCTP_PORT_IUA,           iua_handle);
 979   dissector_add_uint("sctp.ppi",  IUA_PAYLOAD_PROTOCOL_ID, iua_handle);
 980
 981   lapd_gsm_sapi_dissector_table = find_dissector_table("lapd.gsm.sapi");
 982 }
 983
 984 /*
 985  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
 986  *
 987  * Local Variables:
 988  * c-basic-offset: 2
 989  * tab-width: 8
 990  * indent-tabs-mode: nil
 991  * End:
 992  *
 993  * ex: set shiftwidth=2 tabstop=8 expandtab:
 994  * :indentSize=2:tabSize=8:noTabs=true:
 995  */