packet-iua.c

   1 /* packet-iua.c
   2  * Routines for ISDN Q.921-User Adaptation Layer dissection
   3  * It is hopefully (needs testing) compilant to
   4  * http://www.ietf.org/internet-drafts/draft-ietf-sigtran-iua-10.txt
   5  * To do: - clean up the code
   6  *        - provide better handling of length parameters
   7  *        - think about making use of the existing Q.931 dissector
   8  *
   9  * Copyright 2000, Michael Tüxen <Michael.Tuexen@icn.siemens.de>
  10  *
  11  * $Id: packet-iua.c,v 1.13 2002/01/24 09:20:49 guy Exp $
  12  *
  13  * Ethereal - Network traffic analyzer
  14  * By Gerald Combs <gerald@ethereal.com>
  15  * Copyright 1998 Gerald Combs
  16  *
  17  * Copied from README.developer
  18  *
  19  * This program is free software; you can redistribute it and/or
  20  * modify it under the terms of the GNU General Public License
  21  * as published by the Free Software Foundation; either version 2
  22  * of the License, or (at your option) any later version.
  23  *
  24  * This program is distributed in the hope that it will be useful,
  25  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27  * GNU General Public License for more details.
  28  *
  29  * You should have received a copy of the GNU General Public License
  30  * along with this program; if not, write to the Free Software
  31  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  32  */
  33
  34 #ifdef HAVE_CONFIG_H
  35 # include "config.h"
  36 #endif
  37
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40
  41
  42 #ifdef HAVE_SYS_TYPES_H
  43 # include <sys/types.h>
  44 #endif
  45
  46 #ifdef HAVE_NETINET_IN_H
  47 # include <netinet/in.h>
  48 #endif
  49
  50 #include <string.h>
  51 #include <glib.h>
  52
  53 #ifdef NEED_SNPRINTF_H
  54 # include "snprintf.h"
  55 #endif
  56
  57 #include <epan/packet.h>
  58
  59 #define SCTP_PORT_IUA 9900
  60 #define IUA_PAYLOAD_PROTO_ID   1
  61
  62 #define VERSION_LENGTH         1
  63 #define RESERVED_LENGTH        1
  64 #define MESSAGE_CLASS_LENGTH   1
  65 #define MESSAGE_TYPE_LENGTH    1
  66 #define MESSAGE_LENGTH_LENGTH  4
  67 #define COMMON_HEADER_LENGTH   (VERSION_LENGTH + RESERVED_LENGTH + MESSAGE_CLASS_LENGTH + \
  68                                 MESSAGE_TYPE_LENGTH + MESSAGE_LENGTH_LENGTH)
  69
  70 #define VERSION_OFFSET         0
  71 #define RESERVED_OFFSET        (VERSION_OFFSET + VERSION_LENGTH)
  72 #define MESSAGE_CLASS_OFFSET   (RESERVED_OFFSET + RESERVED_LENGTH)
  73 #define MESSAGE_TYPE_OFFSET    (MESSAGE_CLASS_OFFSET + MESSAGE_CLASS_LENGTH)
  74 #define MESSAGE_LENGTH_OFFSET  (MESSAGE_TYPE_OFFSET + MESSAGE_TYPE_LENGTH)
  75
  76 #define PROTOCOL_VERSION_RELEASE_1             1
  77
  78 static const value_string iua_protocol_version_values[] = {
  79   { PROTOCOL_VERSION_RELEASE_1,  "Release 1" },
  80   { 0,                           NULL } };
  81
  82 #define MESSAGE_CLASS_MGMT_MESSAGE        0
  83 #define MESSAGE_CLASS_TFER_MESSAGE        1
  84 #define MESSAGE_CLASS_SSNM_MESSAGE        2
  85 #define MESSAGE_CLASS_ASPSM_MESSAGE       3
  86 #define MESSAGE_CLASS_ASPTM_MESSAGE       4
  87 #define MESSAGE_CLASS_QPTM_MESSAGE        5
  88 #define MESSAGE_CLASS_MAUP_MESSAGE        6
  89 #define MESSAGE_CLASS_CL_SUA_MESSAGE      7
  90 #define MESSAGE_CLASS_CO_SUA_MESSAGE      8
  91
  92 static const value_string iua_message_class_values[] = {
  93   { MESSAGE_CLASS_MGMT_MESSAGE,   "Management messages" },
  94   { MESSAGE_CLASS_TFER_MESSAGE,   "Transfer messages" },
  95   { MESSAGE_CLASS_SSNM_MESSAGE,   "SS7 signalling network management messages" },
  96   { MESSAGE_CLASS_ASPSM_MESSAGE,  "ASP state maintenance messages" },
  97   { MESSAGE_CLASS_ASPTM_MESSAGE,  "ASP traffic maintenance messages" },
  98   { MESSAGE_CLASS_QPTM_MESSAGE,   "Q.921/Q.931 boundary primitive transport messages" },
  99   { MESSAGE_CLASS_MAUP_MESSAGE,   "MTP2 user adaptation messages" },
 100   { MESSAGE_CLASS_CL_SUA_MESSAGE, "Connectionless messages (SUA)" },
 101   { MESSAGE_CLASS_CO_SUA_MESSAGE, "Connection-oriented messages (SUA)" },
 102   { 0,                             NULL } };
 103
 104 /* message types for MGMT messages */
 105 #define MESSAGE_TYPE_ERR                  0
 106 #define MESSAGE_TYPE_NTFY                 1
 107 #define MESSAGE_TYPE_TEI_STATUS_REQ       2
 108 #define MESSAGE_TYPE_TEI_STATUS_CON       3
 109 #define MESSAGE_TYPE_TEI_STATUS_IND       4
 110
 111 /* message types for ASPSM messages */
 112 #define MESSAGE_TYPE_UP                   1
 113 #define MESSAGE_TYPE_DOWN                 2
 114 #define MESSAGE_TYPE_BEAT                 3
 115 #define MESSAGE_TYPE_UP_ACK               4
 116 #define MESSAGE_TYPE_DOWN_ACK             5
 117 #define MESSAGE_TYPE_BEAT_ACK             6
 118
 119 /* message types for ASPTM messages */
 120 #define MESSAGE_TYPE_ACTIVE               1
 121 #define MESSAGE_TYPE_INACTIVE             2
 122 #define MESSAGE_TYPE_ACTIVE_ACK           3
 123 #define MESSAGE_TYPE_INACTIVE_ACK         4
 124
 125 /* message types for QPTM messages */
 126 #define MESSAGE_TYPE_DATA_REQUEST         1
 127 #define MESSAGE_TYPE_DATA_INDICATION      2
 128 #define MESSAGE_TYPE_UNIT_DATA_REQUEST    3
 129 #define MESSAGE_TYPE_UNIT_DATA_INDICATION 4
 130 #define MESSAGE_TYPE_ESTABLISH_REQUEST    5
 131 #define MESSAGE_TYPE_ESTABLISH_CONFIRM    6
 132 #define MESSAGE_TYPE_ESTABLISH_INDICATION 7
 133 #define MESSAGE_TYPE_RELEASE_REQUEST      8
 134 #define MESSAGE_TYPE_RELEASE_CONFIRM      9
 135 #define MESSAGE_TYPE_RELEASE_INDICATION  10
 136
 137
 138 static const value_string iua_message_class_type_values[] = {
 139   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_ERR,                  "Error" },
 140   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_NTFY,                 "Notify" },
 141   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_REQ,       "TEI status request" },
 142   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_CON,       "TEI status confirmation" },
 143   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_IND,       "TEI status indication" },
 144   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_UP,                   "ASP up" },
 145   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_DOWN,                 "ASP down" },
 146   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_BEAT,                 "Heartbeat" },
 147   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_UP_ACK,               "ASP up ack" },
 148   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_DOWN_ACK,             "ASP down ack" },
 149   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_BEAT_ACK,             "Heartbeat ack" },
 150   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_ACTIVE ,              "ASP active" },
 151   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_INACTIVE ,            "ASP inactive" },
 152   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_ACTIVE_ACK ,          "ASP active ack" },
 153   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_INACTIVE_ACK ,        "ASP inactive ack" },
 154   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_DATA_REQUEST,         "Data request" },
 155   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_DATA_INDICATION,      "Data indication" },
 156   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_UNIT_DATA_REQUEST,    "Unit data request" },
 157   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_UNIT_DATA_INDICATION, "Unit data indication" },
 158   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_REQUEST,    "Establish request" },
 159   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_CONFIRM,    "Establish confirmation" },
 160   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_INDICATION, "Establish indication" },
 161   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_REQUEST,      "Release request" },
 162   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_CONFIRM,      "Release confirmation" },
 163   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_INDICATION,   "Release indication" },
 164   { 0,                                                                     NULL } };
 165
 166 static const value_string iua_message_class_type_acro_values[] = {
 167   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_ERR,                  "ERR" },
 168   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_NTFY,                 "NTFY" },
 169   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_REQ,       "TEI_STAT_REQ" },
 170   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_CON,       "TEI_STAT_CON" },
 171   { MESSAGE_CLASS_MGMT_MESSAGE  * 256 + MESSAGE_TYPE_TEI_STATUS_IND,       "TEI_STAT_IND" },
 172   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_UP,                   "ASP_UP" },
 173   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_DOWN,                 "ASP_DOWN" },
 174   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_BEAT,                 "BEAT" },
 175   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_UP_ACK,               "ASP_UP_ACK" },
 176   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_DOWN_ACK,             "ASP_DOWN_ACK" },
 177   { MESSAGE_CLASS_ASPSM_MESSAGE * 256 + MESSAGE_TYPE_BEAT_ACK,             "BEAT_ACK" },
 178   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_ACTIVE ,              "ASP_ACTIVE" },
 179   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_INACTIVE ,            "ASP_INACTIVE" },
 180   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_ACTIVE_ACK ,          "ASP_ACTIVE_ACK" },
 181   { MESSAGE_CLASS_ASPTM_MESSAGE * 256 + MESSAGE_TYPE_INACTIVE_ACK ,        "ASP_INACTIVE_ACK" },
 182   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_DATA_REQUEST,         "DATA_REQ" },
 183   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_DATA_INDICATION,      "DATA_IND" },
 184   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_UNIT_DATA_REQUEST,    "U_DATA_REQ" },
 185   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_UNIT_DATA_INDICATION, "U_DATA_IND" },
 186   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_REQUEST,    "EST_REQ" },
 187   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_CONFIRM,    "EST_CON" },
 188   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_ESTABLISH_INDICATION, "EST_IND" },
 189   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_REQUEST,      "REL_REQ" },
 190   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_CONFIRM,      "REL_CON" },
 191   { MESSAGE_CLASS_QPTM_MESSAGE  * 256 + MESSAGE_TYPE_RELEASE_INDICATION,   "REL_IND" },
 192   { 0,                                                                     NULL } };
 193
 194 #define PARAMETER_TAG_LENGTH    2
 195 #define PARAMETER_LENGTH_LENGTH 2
 196 #define PARAMETER_HEADER_LENGTH (PARAMETER_TAG_LENGTH + PARAMETER_LENGTH_LENGTH)
 197
 198 #define PARAMETER_TAG_OFFSET      0
 199 #define PARAMETER_LENGTH_OFFSET   (PARAMETER_TAG_OFFSET + PARAMETER_TAG_LENGTH)
 200 #define PARAMETER_VALUE_OFFSET    (PARAMETER_LENGTH_OFFSET + PARAMETER_LENGTH_LENGTH)
 201 #define PARAMETER_HEADER_OFFSET   PARAMETER_TAG_OFFSET
 202
 203 #define INT_INTERFACE_IDENTIFIER_PARAMETER_TAG           0x01
 204 #define TEXT_INTERFACE_IDENTIFIER_PARAMETER_TAG          0x03
 205 #define INFO_PARAMETER_TAG                               0x04
 206 #define DLCI_PARAMETER_TAG                               0x05
 207 #define DIAGNOSTIC_INFORMATION_PARAMETER_TAG             0x07
 208 #define INTEGER_RANGE_INTERFACE_IDENTIFIER_PARAMETER_TAG 0x08
 209 #define HEARTBEAT_DATA_PARAMETER_TAG                     0x09
 210 #define ASP_REASON_PARAMETER_TAG                         0x0a
 211 #define TRAFFIC_MODE_TYPE_PARAMETER_TAG                  0x0b
 212 #define ERROR_CODE_PARAMETER_TAG                         0x0c
 213 #define STATUS_TYPE_INDENTIFICATION_PARAMETER_TAG        0x0d
 214 #define PROTOCOL_DATA_PARAMETER_TAG                      0x0e
 215 #define RELEASE_REASON_PARAMETER_TAG                     0x0f
 216 #define TEI_STATUS_PARAMETER_TAG                         0x10
 217
 218 static const value_string iua_parameter_tag_values[] = {
 219   { INT_INTERFACE_IDENTIFIER_PARAMETER_TAG,                "Integer interface identifier" },
 220   { TEXT_INTERFACE_IDENTIFIER_PARAMETER_TAG,               "Text interface identifier" },
 221   { INFO_PARAMETER_TAG,                                    "Info" },
 222   { DLCI_PARAMETER_TAG,                                    "DLCI" },
 223   { DIAGNOSTIC_INFORMATION_PARAMETER_TAG,                  "Diagnostic information" },
 224   { INTEGER_RANGE_INTERFACE_IDENTIFIER_PARAMETER_TAG,      "Integer range interface identifier" },
 225   { HEARTBEAT_DATA_PARAMETER_TAG,                          "Hearbeat data" },
 226   { ASP_REASON_PARAMETER_TAG,                              "Reason" },
 227   { TRAFFIC_MODE_TYPE_PARAMETER_TAG,                       "Traffic mode type" },
 228   { ERROR_CODE_PARAMETER_TAG,                              "Error code" },
 229   { STATUS_TYPE_INDENTIFICATION_PARAMETER_TAG,             "Status type/identification" },
 230   { PROTOCOL_DATA_PARAMETER_TAG,                           "Protocol data" },
 231   { RELEASE_REASON_PARAMETER_TAG,                          "Reason" },
 232   { TEI_STATUS_PARAMETER_TAG,                              "TEI status" },
 233   { 0,                           NULL } };
 234
 235
 236 #define INT_INTERFACE_IDENTIFIER_OFFSET PARAMETER_VALUE_OFFSET
 237 #define INT_INTERFACE_IDENTIFIER_LENGTH 4
 238
 239 #define TEXT_INTERFACE_IDENTIFIER_OFFSET PARAMETER_VALUE_OFFSET
 240 #define TEXT_INTERFACE_IDENTIFIER_LENGTH 4
 241
 242 #define INFO_STRING_OFFSET PARAMETER_VALUE_OFFSET
 243
 244 #define START_LENGTH 4
 245 #define END_LENGTH   4
 246 #define START_OFFSET 0
 247 #define END_OFFSET   (START_OFFSET + START_LENGTH)
 248
 249 #define DLCI_LENGTH 2
 250 #define DLCI_OFFSET PARAMETER_VALUE_OFFSET
 251
 252 #define ZERO_BIT_MASK 0x80
 253 #define SPARE_BIT_MASK  0x40
 254 #define SAPI_MASK     0x3f
 255 #define ONE_BIT_MASK   0x80
 256 #define TEI_MASK      0x7f
 257
 258 #define ASP_MGMT_REASON   1
 259
 260 static const value_string iua_asp_reason_values[] = {
 261   { ASP_MGMT_REASON,      "Management inhibit" },
 262   { 0,                    NULL } };
 263
 264 #define ASP_REASON_LENGTH 4
 265 #define ASP_REASON_OFFSET PARAMETER_VALUE_OFFSET
 266
 267 #define OVER_RIDE_TRAFFIC_MODE_TYPE  1
 268 #define LOAD_SHARE_TRAFFIC_MODE_TYPE 2
 269
 270 static const value_string iua_traffic_mode_type_values[] = {
 271   { OVER_RIDE_TRAFFIC_MODE_TYPE,      "Over-ride" },
 272   { LOAD_SHARE_TRAFFIC_MODE_TYPE,     "Load-share" },
 273   { 0,                    NULL } };
 274
 275 #define TRAFFIC_MODE_TYPE_LENGTH 4
 276 #define TRAFFIC_MODE_TYPE_OFFSET PARAMETER_VALUE_OFFSET
 277
 278 #define INVALID_VERSION_ERROR                         0x01
 279 #define INVALID_INTERFACE_IDENTIFIER_ERROR            0x02
 280 #define UNSUPPORTED_MESSAGE_CLASS_ERROR               0x03
 281 #define UNSUPPORTED_MESSAGE_TYPE_ERROR                0x04
 282 #define UNSUPPORTED_TRAFFIC_HANDLING_MODE_ERROR       0x05
 283 #define UNEXPECTED_MESSAGE_ERROR                      0x06
 284 #define PROTOCOL_ERROR                                0x07
 285 #define UNSUPPORTED_INTERFACE_IDENTIFIER_TYPE_ERROR   0x08
 286 #define INVALID_STREAM_IDENTIFIER_ERROR               0x09
 287 #define UNASSIGNED_TEI_ERROR                          0x0a
 288 #define UNRECOGNIZED_SAPI_ERROR                       0x0b
 289 #define INVALID_TEI_SAPI_COMBINATION                  0x0c
 290
 291 static const value_string iua_error_code_values[] = {
 292   { INVALID_VERSION_ERROR,                       "Invalid version" },
 293   { INVALID_INTERFACE_IDENTIFIER_ERROR,          "Invalid interface identifier" },
 294   { UNSUPPORTED_MESSAGE_CLASS_ERROR,             "Unsuported message class" },
 295   { UNSUPPORTED_MESSAGE_TYPE_ERROR,              "Unsupported message type" },
 296   { UNSUPPORTED_TRAFFIC_HANDLING_MODE_ERROR,     "Unsupported traffic handling mode" },
 297   { UNEXPECTED_MESSAGE_ERROR,                    "Unexpected message" },
 298   { PROTOCOL_ERROR,                              "Protocol error" },
 299   { UNSUPPORTED_INTERFACE_IDENTIFIER_TYPE_ERROR, "Unsupported interface identifier type" },
 300   { INVALID_STREAM_IDENTIFIER_ERROR,             "Invalid stream identifier" },
 301   { UNASSIGNED_TEI_ERROR,                        "Unassigned TEI" },
 302   { UNRECOGNIZED_SAPI_ERROR,                     "Unrecognized SAPI" },
 303   { INVALID_TEI_SAPI_COMBINATION,                "Invalid TEI/SAPI combination" },
 304   { 0,                                           NULL } };
 305
 306 #define ERROR_CODE_LENGTH 4
 307 #define ERROR_CODE_OFFSET PARAMETER_VALUE_OFFSET
 308
 309 #define ASP_STATE_CHANGE_STATUS_TYPE  0x01
 310 #define OTHER_STATUS_TYPE             0x02
 311
 312 static const value_string iua_status_type_values[] = {
 313   { ASP_STATE_CHANGE_STATUS_TYPE,        "Application server state change" },
 314   { OTHER_STATUS_TYPE,                   "Other" },
 315   { 0,                                   NULL } };
 316
 317 #define AS_DOWN_STATUS_IDENT          0x01
 318 #define AS_INACTIVE_STATUS_IDENT      0x02
 319 #define AS_ACTIVE_STATUS_IDENT        0x03
 320 #define AS_PENDING_STATUS_IDENT       0x04
 321
 322 #define INSUFFICIENT_ASP_RESOURCES_STATUS_IDENT 0x01
 323 #define ALTERNATE_ASP_ACTIVE_STATUS_IDENT       0x02
 324
 325 static const value_string iua_status_type_ident_values[] = {
 326   { ASP_STATE_CHANGE_STATUS_TYPE * 256 * 256 + AS_DOWN_STATUS_IDENT,         "Application server down" },
 327   { ASP_STATE_CHANGE_STATUS_TYPE * 256 * 256 + AS_INACTIVE_STATUS_IDENT,     "Application server inactive" },
 328   { ASP_STATE_CHANGE_STATUS_TYPE * 256 * 256 + AS_ACTIVE_STATUS_IDENT,       "Application server active" },
 329   { ASP_STATE_CHANGE_STATUS_TYPE * 256 * 256 + AS_PENDING_STATUS_IDENT,      "Application server pending" },
 330   { OTHER_STATUS_TYPE * 256 * 256 + INSUFFICIENT_ASP_RESOURCES_STATUS_IDENT, "Insufficient ASP resources active in AS" },
 331   { OTHER_STATUS_TYPE * 256 * 256 + ALTERNATE_ASP_ACTIVE_STATUS_IDENT,       "Alternate ASP active" },
 332   { 0,                                           NULL } };
 333
 334 #define STATUS_TYPE_LENGTH  2
 335 #define STATUS_IDENT_LENGTH 2
 336 #define STATUS_TYPE_OFFSET  PARAMETER_VALUE_OFFSET
 337 #define STATUS_IDENT_OFFSET (STATUS_TYPE_OFFSET + STATUS_TYPE_LENGTH)
 338
 339 #define PROTOCOL_DATA_OFFSET PARAMETER_VALUE_OFFSET
 340
 341 #define RELEASE_MGMT_REASON   0
 342 #define RELEASE_PHYS_REASON   1
 343 #define RELEASE_DM_REASON     2
 344 #define RELEASE_OTHER_REASON  4
 345
 346 static const value_string iua_release_reason_values[] = {
 347   { RELEASE_MGMT_REASON,  "Management layer generated release" },
 348   { RELEASE_PHYS_REASON,  "Physical layer alarm generated release" },
 349   { RELEASE_DM_REASON,    "Layer 2 should release" },
 350   { RELEASE_OTHER_REASON, "Other reason" },
 351   { 0,                    NULL } };
 352
 353 #define RELEASE_REASON_OFFSET PARAMETER_VALUE_OFFSET
 354 #define RELEASE_REASON_LENGTH 4
 355
 356 #define TEI_STATUS_ASSIGNED       0
 357 #define TEI_STATUS_UNASSIGNED     1
 358
 359 static const value_string iua_tei_status_values[] = {
 360   { TEI_STATUS_ASSIGNED,   "TEI is considered assigned by Q.921" },
 361   { TEI_STATUS_UNASSIGNED, "TEI is considered unassigned by Q.921" },
 362   { 0,                    NULL } };
 363
 364 #define TEI_STATUS_LENGTH 4
 365 #define TEI_STATUS_OFFSET PARAMETER_VALUE_OFFSET
 366
 367 /* Initialize the protocol and registered fields */
 368 static int proto_iua = -1;
 369 static int hf_iua_version = -1;
 370 static int hf_iua_reserved = -1;
 371 static int hf_iua_message_class = -1;
 372 static int hf_iua_message_type = -1;
 373 static int hf_iua_message_length = -1;
 374 static int hf_iua_parameter_tag = -1;
 375 static int hf_iua_parameter_length = -1;
 376 static int hf_iua_int_interface_identifier = -1;
 377 static int hf_iua_text_interface_identifier = -1;
 378 static int hf_iua_info_string = -1;
 379 static int hf_iua_interface_range_start = -1;
 380 static int hf_iua_interface_range_end = -1;
 381 static int hf_iua_zero_bit = -1;
 382 static int hf_iua_spare_bit = -1;
 383 static int hf_iua_sapi = -1;
 384 static int hf_iua_one_bit = -1;
 385 static int hf_iua_tei = -1;
 386 static int hf_iua_status_type = -1;
 387 static int hf_iua_status_ident = -1;
 388 static int hf_iua_release_reason = -1;
 389 static int hf_iua_traffic_mode_type = -1;
 390 static int hf_iua_error_code = -1;
 391 static int hf_iua_asp_reason = -1;
 392 static int hf_iua_tei_status = -1;
 393
 394 /* Initialize the subtree pointers */
 395 static gint ett_iua = -1;
 396 static gint ett_iua_parameter = -1;
 397 static gint ett_iua_dlci = -1;
 398 static gint ett_iua_range = -1;
 399
 400 static guint
 401 nr_of_padding_bytes (guint length)
 402 {
 403   guint remainder;
 404
 405   remainder = length % 4;
 406
 407   if (remainder == 0)
 408     return 0;
 409   else
 410     return 4 - remainder;
 411 }
 412
 413 static void
 414 dissect_iua_common_header(tvbuff_t *common_header_tvb, packet_info *pinfo, proto_tree *iua_tree)
 415 {
 416   guint8  version, reserved, message_class, message_type;
 417   guint32 message_length;
 418
 419   /* Extract the common header */
 420   version        = tvb_get_guint8(common_header_tvb, VERSION_OFFSET);
 421   reserved       = tvb_get_guint8(common_header_tvb, RESERVED_OFFSET);
 422   message_class  = tvb_get_guint8(common_header_tvb, MESSAGE_CLASS_OFFSET);
 423   message_type   = tvb_get_guint8(common_header_tvb, MESSAGE_TYPE_OFFSET);
 424   message_length = tvb_get_ntohl (common_header_tvb, MESSAGE_LENGTH_OFFSET);
 425
 426   if (check_col(pinfo->cinfo, COL_INFO)) {
 427     col_append_str(pinfo->cinfo, COL_INFO, val_to_str(message_class * 256 + message_type, iua_message_class_type_acro_values, "UNKNOWN"));
 428     col_append_str(pinfo->cinfo, COL_INFO, " ");
 429   };
 430
 431   if (iua_tree) {
 432     /* add the components of the common header to the protocol tree */
 433     proto_tree_add_uint_format(iua_tree, hf_iua_version,
 434                                common_header_tvb, VERSION_OFFSET, VERSION_LENGTH,
 435                                version, "Version: %u (%s)",
 436                                version, val_to_str(version, iua_protocol_version_values, "unknown"));
 437     proto_tree_add_uint(iua_tree, hf_iua_reserved,
 438                         common_header_tvb, RESERVED_OFFSET, RESERVED_LENGTH,
 439                         reserved);
 440     proto_tree_add_uint_format(iua_tree, hf_iua_message_class,
 441                                common_header_tvb, MESSAGE_CLASS_OFFSET, MESSAGE_CLASS_LENGTH,
 442                                message_class, "Message class: %u (%s)",
 443                                message_class, val_to_str(message_class, iua_message_class_values, "reserved"));
 444     proto_tree_add_uint_format(iua_tree, hf_iua_message_type,
 445                                common_header_tvb, MESSAGE_TYPE_OFFSET, MESSAGE_TYPE_LENGTH,
 446                                message_type, "Message type: %u (%s)",
 447                                message_type, val_to_str(message_class * 256 + message_type, iua_message_class_type_values, "reserved"));
 448     proto_tree_add_uint(iua_tree, hf_iua_message_length,
 449                         common_header_tvb, MESSAGE_LENGTH_OFFSET, MESSAGE_LENGTH_LENGTH,
 450                         message_length);
 451   }
 452 }
 453
 454 static void
 455 dissect_iua_int_interface_identifier_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 456 {
 457   guint32 interface_identifier;
 458
 459   interface_identifier = tvb_get_ntohl(parameter_tvb, INT_INTERFACE_IDENTIFIER_OFFSET);
 460
 461   proto_tree_add_uint(parameter_tree, hf_iua_int_interface_identifier,
 462                       parameter_tvb, INT_INTERFACE_IDENTIFIER_OFFSET, INT_INTERFACE_IDENTIFIER_LENGTH,
 463                       interface_identifier);
 464
 465   proto_item_set_text(parameter_item, "Integer interface identifier (%u)", interface_identifier);
 466 }
 467
 468 static void
 469 dissect_iua_text_interface_identifier_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 470 {
 471   guint16 length, interface_identifier_length;
 472   char *interface_identifier;
 473
 474   length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET);
 475
 476   interface_identifier_length = length - PARAMETER_HEADER_LENGTH;
 477   interface_identifier = (char *)tvb_get_ptr(parameter_tvb, TEXT_INTERFACE_IDENTIFIER_OFFSET, interface_identifier_length);
 478
 479   proto_tree_add_string(parameter_tree, hf_iua_text_interface_identifier,
 480                         parameter_tvb, TEXT_INTERFACE_IDENTIFIER_OFFSET, interface_identifier_length ,
 481                         interface_identifier);
 482
 483   proto_item_set_text(parameter_item, "Text interface identifier (%s)", interface_identifier);
 484 }
 485
 486 static void
 487 dissect_iua_info_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 488 {
 489   guint16 length, info_string_length;
 490   char *info_string;
 491
 492   length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET);
 493
 494   info_string_length = length - PARAMETER_HEADER_LENGTH;
 495   info_string = (char *)tvb_get_ptr(parameter_tvb, INFO_STRING_OFFSET, info_string_length);
 496
 497   proto_tree_add_string(parameter_tree, hf_iua_info_string,
 498                         parameter_tvb, INFO_STRING_OFFSET, info_string_length ,
 499                         info_string);
 500
 501   proto_item_set_text(parameter_item, "Info String (%s)", info_string);
 502 }
 503
 504 static void
 505 dissect_iua_dlci_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 506 {
 507   guint16 dlci;
 508   proto_item *dlci_item;
 509   proto_tree *dlci_tree;
 510
 511   dlci  = tvb_get_ntohs(parameter_tvb, DLCI_OFFSET);
 512   dlci_item   = proto_tree_add_text(parameter_tree, parameter_tvb, DLCI_OFFSET, DLCI_LENGTH, "DLCI");
 513   dlci_tree   = proto_item_add_subtree(dlci_item, ett_iua_dlci);
 514
 515   proto_tree_add_boolean(dlci_tree, hf_iua_zero_bit, parameter_tvb, DLCI_OFFSET, 1, dlci);
 516   proto_tree_add_boolean(dlci_tree, hf_iua_spare_bit, parameter_tvb, DLCI_OFFSET, 1, dlci);
 517   proto_tree_add_uint(dlci_tree, hf_iua_sapi, parameter_tvb, DLCI_OFFSET, 1, dlci);
 518   proto_tree_add_boolean(dlci_tree, hf_iua_one_bit, parameter_tvb, DLCI_OFFSET+1, 1, dlci);
 519   proto_tree_add_uint(dlci_tree, hf_iua_tei, parameter_tvb, DLCI_OFFSET+1, 1, dlci);
 520
 521   proto_item_set_text(parameter_item, "DLCI");
 522 }
 523
 524 static void
 525 dissect_iua_diagnostic_information_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 526 {
 527   guint16 length, diagnostic_info_length;
 528
 529   length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET);
 530
 531   diagnostic_info_length = length - PARAMETER_HEADER_LENGTH;
 532
 533   proto_tree_add_text(parameter_tree, parameter_tvb, PARAMETER_VALUE_OFFSET, diagnostic_info_length,
 534                       "Diagnostic information (%u byte%s)",
 535                       diagnostic_info_length, plurality(diagnostic_info_length, "", "s"));
 536
 537   proto_item_set_text(parameter_item, "Diagnostic information (%u byte%s)",
 538                       diagnostic_info_length, plurality(diagnostic_info_length, "", "s"));
 539 }
 540
 541 static void
 542 dissect_iua_integer_range_interface_identifier_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 543 {
 544   guint16 length, number_of_ranges, range_number;
 545   guint32 start, end;
 546   gint    offset;
 547
 548   proto_item *range_item;
 549   proto_tree *range_tree;
 550
 551   length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET);
 552
 553   number_of_ranges = (length - PARAMETER_HEADER_LENGTH) / (2 * 4);
 554
 555   offset = PARAMETER_VALUE_OFFSET;
 556   for(range_number = 1; range_number <= number_of_ranges; range_number++) {
 557     start = tvb_get_ntohl(parameter_tvb, offset + START_OFFSET);
 558     end   = tvb_get_ntohl(parameter_tvb, offset + END_OFFSET);
 559     range_item = proto_tree_add_text(parameter_tree, parameter_tvb,
 560                                      offset + START_OFFSET, START_LENGTH + END_LENGTH,
 561                                      "Integer interface range: %u - %u",
 562                                      start, end);
 563     range_tree = proto_item_add_subtree(range_item, ett_iua_range);
 564     proto_tree_add_uint(range_tree, hf_iua_interface_range_start,
 565                         parameter_tvb,
 566                         offset + START_OFFSET, START_LENGTH,
 567                         start);
 568     proto_tree_add_uint(range_tree, hf_iua_interface_range_end,
 569                         parameter_tvb,
 570                         offset + END_OFFSET, END_LENGTH,
 571                         end);
 572     offset += START_LENGTH + END_LENGTH;
 573   };
 574
 575   proto_item_set_text(parameter_item, "Integer interface identifier (%u range%s)",
 576                       number_of_ranges, plurality(number_of_ranges, "", "s"));
 577 }
 578
 579 static void
 580 dissect_iua_heartbeat_data_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 581 {
 582   guint16 length, heartbeat_data_length;
 583
 584   length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET);
 585
 586   heartbeat_data_length = length - PARAMETER_HEADER_LENGTH;
 587
 588   proto_tree_add_text(parameter_tree, parameter_tvb, PARAMETER_VALUE_OFFSET, heartbeat_data_length,
 589                       "Heartbeat data (%u byte%s)",
 590                       heartbeat_data_length, plurality(heartbeat_data_length, "", "s"));
 591
 592   proto_item_set_text(parameter_item, "Heartbeat data (%u byte%s)",
 593                       heartbeat_data_length, plurality(heartbeat_data_length, "", "s"));
 594 }
 595
 596 static void
 597 dissect_iua_asp_reason_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 598 {
 599   guint32 reason;
 600
 601   reason = tvb_get_ntohl(parameter_tvb, ASP_REASON_OFFSET);
 602
 603   proto_tree_add_uint_format(parameter_tree, hf_iua_asp_reason,
 604                              parameter_tvb, ASP_REASON_OFFSET, ASP_REASON_LENGTH,
 605                              reason, "Reason: %u (%s)",
 606                              reason, val_to_str(reason, iua_asp_reason_values, "unknown"));
 607
 608   proto_item_set_text(parameter_item, "Reason (%s)", val_to_str(reason, iua_asp_reason_values, "unknown"));
 609 }
 610
 611 static void
 612 dissect_iua_traffic_mode_type_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 613 {
 614   guint32 traffic_mode_type;
 615
 616   traffic_mode_type = tvb_get_ntohl(parameter_tvb, TRAFFIC_MODE_TYPE_OFFSET);
 617
 618   proto_tree_add_uint_format(parameter_tree, hf_iua_traffic_mode_type,
 619                              parameter_tvb, TRAFFIC_MODE_TYPE_OFFSET, TRAFFIC_MODE_TYPE_LENGTH,
 620                              traffic_mode_type, "Traffic mode type: %u (%s)",
 621                              traffic_mode_type, val_to_str(traffic_mode_type, iua_traffic_mode_type_values, "unknown"));
 622
 623   proto_item_set_text(parameter_item, "Traffic mode type (%s)",
 624                       val_to_str(traffic_mode_type, iua_traffic_mode_type_values, "unknown"));
 625 }
 626
 627 static void
 628 dissect_iua_error_code_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 629 {
 630   guint32 error_code;
 631
 632   error_code = tvb_get_ntohl(parameter_tvb, ERROR_CODE_OFFSET);
 633   proto_tree_add_uint_format(parameter_tree, hf_iua_error_code,
 634                              parameter_tvb, ERROR_CODE_OFFSET, ERROR_CODE_LENGTH,
 635                              error_code, "Error code: %u (%s)",
 636                              error_code, val_to_str(error_code, iua_error_code_values, "unknown"));
 637   proto_item_set_text(parameter_item, "Error code (%s)",
 638                       val_to_str(error_code, iua_error_code_values, "unknown"));
 639 }
 640
 641 static void
 642 dissect_iua_status_type_identification_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 643 {
 644   guint16 status_type, status_ident;
 645
 646   status_type  = tvb_get_ntohs(parameter_tvb, STATUS_TYPE_OFFSET);
 647   status_ident = tvb_get_ntohs(parameter_tvb, STATUS_IDENT_OFFSET);
 648
 649   proto_tree_add_uint_format(parameter_tree, hf_iua_status_type,
 650                              parameter_tvb, STATUS_TYPE_OFFSET, STATUS_TYPE_LENGTH,
 651                              status_type, "Status type: %u (%s)",
 652                              status_type, val_to_str(status_type, iua_status_type_values, "unknown"));
 653   proto_tree_add_uint_format(parameter_tree, hf_iua_status_ident,
 654                              parameter_tvb, STATUS_IDENT_OFFSET, STATUS_IDENT_LENGTH,
 655                              status_ident, "Status identification: %u (%s)",
 656                              status_ident, val_to_str(status_type * 256 * 256 +
 657                                                      status_ident, iua_status_type_ident_values, "unknown"));
 658
 659   proto_item_set_text(parameter_item, "Status type / status identification (%s)",
 660                       val_to_str(status_type * 256 * 256 +
 661                                  status_ident, iua_status_type_ident_values, "unknown status information"));
 662 }
 663
 664 static void
 665 dissect_iua_protocol_data_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 666 {
 667   guint16 length, protocol_data_length;
 668
 669   length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET);
 670
 671   protocol_data_length = length - PARAMETER_HEADER_LENGTH;
 672
 673   proto_tree_add_text(parameter_tree, parameter_tvb, PROTOCOL_DATA_OFFSET, protocol_data_length,
 674                       "Protocol data (%u byte%s)",
 675                       protocol_data_length, plurality(protocol_data_length, "", "s"));
 676
 677   proto_item_set_text(parameter_item, "Protocol data (%u byte%s)",
 678                       protocol_data_length, plurality(protocol_data_length, "", "s"));
 679 }
 680
 681 static void
 682 dissect_iua_release_reason_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 683 {
 684   guint32 reason;
 685
 686   reason = tvb_get_ntohl(parameter_tvb, RELEASE_REASON_OFFSET);
 687
 688   proto_tree_add_uint_format(parameter_tree, hf_iua_release_reason,
 689                              parameter_tvb, RELEASE_REASON_OFFSET, RELEASE_REASON_LENGTH,
 690                              reason, "Reason: %u (%s)",
 691                              reason, val_to_str(reason, iua_release_reason_values, "unknown"));
 692
 693   proto_item_set_text(parameter_item, "Reason (%s)", val_to_str(reason, iua_release_reason_values, "unknown"));
 694 }
 695
 696 static void
 697 dissect_iua_tei_status_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 698 {
 699   guint32 status;
 700
 701   status = tvb_get_ntohl(parameter_tvb, TEI_STATUS_OFFSET);
 702
 703   proto_tree_add_uint_format(parameter_tree, hf_iua_release_reason,
 704                              parameter_tvb, TEI_STATUS_OFFSET, TEI_STATUS_LENGTH,
 705                              status, "TEI status: %u (%s)",
 706                              status, val_to_str(status, iua_tei_status_values, "unknown"));
 707
 708   proto_item_set_text(parameter_item, "TEI status (%s)", val_to_str(status, iua_tei_status_values, "unknown"));
 709 }
 710
 711 static void
 712 dissect_iua_unknown_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
 713 {
 714   guint16 tag, length, parameter_value_length;
 715
 716   tag    = tvb_get_ntohs(parameter_tvb, PARAMETER_TAG_OFFSET);
 717   length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET);
 718
 719   parameter_value_length = length - PARAMETER_HEADER_LENGTH;
 720
 721   proto_tree_add_text(parameter_tree, parameter_tvb, PARAMETER_VALUE_OFFSET, parameter_value_length,
 722                       "Parameter value (%u byte%s)",
 723                       parameter_value_length, plurality(parameter_value_length, "", "s"));
 724
 725   proto_item_set_text(parameter_item, "Parameter with tag %u and %u byte%s value",
 726                       tag, parameter_value_length, plurality(parameter_value_length, "", "s"));
 727 }
 728
 729 static void
 730 dissect_iua_parameter(tvbuff_t *parameter_tvb, proto_tree *iua_tree)
 731 {
 732   guint16 tag, length, padding_length, total_length;
 733   proto_item *parameter_item;
 734   proto_tree *parameter_tree;
 735
 736   /* extract tag and length from the parameter */
 737   tag            = tvb_get_ntohs(parameter_tvb, PARAMETER_TAG_OFFSET);
 738   length         = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET);
 739
 740   /* calculate padding and total length */
 741   padding_length = nr_of_padding_bytes(length);
 742   total_length   = length + padding_length;
 743
 744   /* create proto_tree stuff */
 745   parameter_item   = proto_tree_add_text(iua_tree, parameter_tvb,
 746                                          PARAMETER_HEADER_OFFSET, total_length, "Incomplete parameter");
 747   parameter_tree   = proto_item_add_subtree(parameter_item, ett_iua_parameter);
 748
 749   /* add tag and length to the m3ua tree */
 750   proto_tree_add_uint_format(parameter_tree, hf_iua_parameter_tag,
 751                              parameter_tvb, PARAMETER_TAG_OFFSET, PARAMETER_TAG_LENGTH,
 752                              tag, "Identifier: %u (%s)",
 753                              tag, val_to_str(tag, iua_parameter_tag_values, "unknown"));
 754   proto_tree_add_uint(parameter_tree, hf_iua_parameter_length,
 755                       parameter_tvb, PARAMETER_LENGTH_OFFSET, PARAMETER_LENGTH_LENGTH,
 756                       length);
 757
 758   switch(tag) {
 759   case INT_INTERFACE_IDENTIFIER_PARAMETER_TAG:
 760     dissect_iua_int_interface_identifier_parameter(parameter_tvb, parameter_tree, parameter_item);
 761     break;
 762   case TEXT_INTERFACE_IDENTIFIER_PARAMETER_TAG:
 763     dissect_iua_text_interface_identifier_parameter(parameter_tvb, parameter_tree, parameter_item);
 764     break;
 765   case INFO_PARAMETER_TAG:
 766     dissect_iua_info_parameter(parameter_tvb, parameter_tree, parameter_item);
 767     break;
 768   case DLCI_PARAMETER_TAG:
 769     dissect_iua_dlci_parameter(parameter_tvb, parameter_tree, parameter_item);
 770     break;
 771   case DIAGNOSTIC_INFORMATION_PARAMETER_TAG:
 772     dissect_iua_diagnostic_information_parameter(parameter_tvb, parameter_tree, parameter_item);
 773     break;
 774   case INTEGER_RANGE_INTERFACE_IDENTIFIER_PARAMETER_TAG:
 775     dissect_iua_integer_range_interface_identifier_parameter(parameter_tvb, parameter_tree, parameter_item);
 776     break;
 777   case HEARTBEAT_DATA_PARAMETER_TAG:
 778     dissect_iua_heartbeat_data_parameter(parameter_tvb, parameter_tree, parameter_item);
 779     break;
 780   case ASP_REASON_PARAMETER_TAG:
 781     dissect_iua_asp_reason_parameter(parameter_tvb, parameter_tree, parameter_item);
 782     break;
 783   case TRAFFIC_MODE_TYPE_PARAMETER_TAG:
 784     dissect_iua_traffic_mode_type_parameter(parameter_tvb, parameter_tree, parameter_item);
 785     break;
 786   case ERROR_CODE_PARAMETER_TAG:
 787     dissect_iua_error_code_parameter(parameter_tvb, parameter_tree, parameter_item);
 788     break;
 789   case STATUS_TYPE_INDENTIFICATION_PARAMETER_TAG:
 790     dissect_iua_status_type_identification_parameter(parameter_tvb, parameter_tree, parameter_item);
 791     break;
 792   case PROTOCOL_DATA_PARAMETER_TAG:
 793     dissect_iua_protocol_data_parameter(parameter_tvb, parameter_tree, parameter_item);
 794     break;
 795   case RELEASE_REASON_PARAMETER_TAG:
 796     dissect_iua_release_reason_parameter(parameter_tvb, parameter_tree, parameter_item);
 797     break;
 798   case TEI_STATUS_PARAMETER_TAG:
 799     dissect_iua_tei_status_parameter(parameter_tvb, parameter_tree, parameter_item);
 800     break;
 801   default:
 802     dissect_iua_unknown_parameter(parameter_tvb, parameter_tree, parameter_item);
 803     break;
 804   };
 805
 806   if (padding_length > 0)
 807     proto_tree_add_text(parameter_tree, parameter_tvb, PARAMETER_HEADER_OFFSET + length, padding_length,
 808                         "Padding: %u byte%s",
 809                         padding_length, plurality(padding_length, "", "s"));
 810 }
 811
 812 static void
 813 dissect_iua_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *iua_tree)
 814 {
 815   gint offset, length, padding_length, total_length;
 816   tvbuff_t *common_header_tvb, *parameter_tvb;
 817
 818   offset = 0;
 819
 820   /* extract and process the common header */
 821   common_header_tvb = tvb_new_subset(message_tvb, offset, COMMON_HEADER_LENGTH, COMMON_HEADER_LENGTH);
 822   dissect_iua_common_header(common_header_tvb, pinfo, iua_tree);
 823   offset += COMMON_HEADER_LENGTH;
 824
 825   if (iua_tree) {
 826     /* extract zero or more parameters and process them individually */
 827     while(tvb_reported_length_remaining(message_tvb, offset)) {
 828       length         = tvb_get_ntohs(message_tvb, offset + PARAMETER_LENGTH_OFFSET);
 829       padding_length = nr_of_padding_bytes(length);
 830       total_length   = length + padding_length;
 831       /* create a tvb for the parameter including the padding bytes */
 832       parameter_tvb    = tvb_new_subset(message_tvb, offset, total_length, total_length);
 833       dissect_iua_parameter(parameter_tvb, iua_tree);
 834       /* get rid of the handled parameter */
 835       offset += total_length;
 836     }
 837   }
 838 }
 839
 840 static void
 841 dissect_iua(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *tree)
 842 {
 843   proto_item *iua_item;
 844   proto_tree *iua_tree;
 845
 846   /* make entry in the Protocol column on summary display */
 847   if (check_col(pinfo->cinfo, COL_PROTOCOL))
 848     col_set_str(pinfo->cinfo, COL_PROTOCOL, "IUA");
 849
 850   /* In the interest of speed, if "tree" is NULL, don't do any work not
 851      necessary to generate protocol tree items. */
 852   if (tree) {
 853     /* create the m3ua protocol tree */
 854     iua_item = proto_tree_add_item(tree, proto_iua, message_tvb, 0, -1, FALSE);
 855     iua_tree = proto_item_add_subtree(iua_item, ett_iua);
 856   } else {
 857     iua_tree = NULL;
 858   };
 859   /* dissect the message */
 860   dissect_iua_message(message_tvb, pinfo, iua_tree);
 861 }
 862
 863 /* Register the protocol with Ethereal */
 864 void
 865 proto_register_iua(void)
 866 {
 867
 868   /* Setup list of header fields */
 869   static hf_register_info hf[] = {
 870     { &hf_iua_version,
 871       { "Version", "iua.version",
 872         FT_UINT8, BASE_DEC, NULL, 0x0,
 873         "", HFILL }
 874     },
 875     { &hf_iua_reserved,
 876       { "Reserved", "iua.reserved",
 877         FT_UINT8, BASE_HEX, NULL, 0x0,
 878         "", HFILL }
 879     },
 880     { &hf_iua_message_class,
 881       { "Message class", "iua.message_class",
 882         FT_UINT8, BASE_DEC, NULL, 0x0,
 883         "", HFILL }
 884     },
 885     { &hf_iua_message_type,
 886       { "Message Type", "iua.message_type",
 887         FT_UINT8, BASE_DEC, NULL, 0x0,
 888         "", HFILL }
 889     },
 890     { &hf_iua_message_length,
 891       { "Message length", "iua.message_length",
 892         FT_UINT32, BASE_DEC, NULL, 0x0,
 893         "", HFILL }
 894     },
 895     { &hf_iua_parameter_tag,
 896       { "Parameter Tag", "iua.parameter_tag",
 897         FT_UINT16, BASE_DEC, NULL, 0x0,
 898         "", HFILL }
 899     },
 900     { &hf_iua_parameter_length,
 901       { "Parameter length", "iua.parameter_length",
 902         FT_UINT16, BASE_DEC, NULL, 0x0,
 903         "", HFILL }
 904     },
 905     { &hf_iua_int_interface_identifier,
 906       { "Integer interface identifier", "iua.int_interface_identifier",
 907         FT_UINT32, BASE_HEX, NULL, 0x0,
 908         "", HFILL }
 909     },
 910     { &hf_iua_text_interface_identifier,
 911       { "Text interface identifier", "iua.text_interface_identifier",
 912         FT_STRING, BASE_DEC, NULL, 0x0,
 913         "", HFILL }
 914     },
 915     { &hf_iua_spare_bit,
 916       { "Spare bit", "iua.spare_bit",
 917         FT_BOOLEAN, 8, NULL, SPARE_BIT_MASK,
 918         "", HFILL }
 919     },
 920     { &hf_iua_sapi,
 921       { "SAPI", "iua.sapi",
 922         FT_UINT8, BASE_HEX, NULL, SAPI_MASK,
 923         "", HFILL }
 924     },
 925     { &hf_iua_zero_bit,
 926       { "Zero bit", "iua.zero_bit",
 927         FT_BOOLEAN, 8, NULL, ZERO_BIT_MASK,
 928         "", HFILL }
 929     },
 930     { &hf_iua_one_bit,
 931       { "One bit", "iua.one_bit",
 932         FT_BOOLEAN, 8, NULL, ONE_BIT_MASK,
 933         "", HFILL }
 934     },
 935     { &hf_iua_tei,
 936       { "TEI", "iua.tei",
 937         FT_UINT8, BASE_HEX, NULL, TEI_MASK,
 938         "", HFILL }
 939     },
 940     { &hf_iua_info_string,
 941       { "Info string", "iua.info_string",
 942         FT_STRING, BASE_DEC, NULL, 0x0,
 943         "", HFILL }
 944     },
 945     { &hf_iua_interface_range_start,
 946       { "Start", "iua.interface_range_start",
 947         FT_UINT32, BASE_DEC, NULL, 0x0,
 948         "", HFILL }
 949     },
 950     { &hf_iua_interface_range_end,
 951       { "End", "iua.interface_range_end",
 952         FT_UINT32, BASE_DEC, NULL, 0x0,
 953         "", HFILL }
 954     },
 955     { &hf_iua_release_reason,
 956       { "Reason", "iua.release_reason",
 957         FT_UINT32, BASE_HEX, NULL, 0x0,
 958         "", HFILL }
 959     },
 960     { &hf_iua_status_type,
 961       { "Status type", "iua.status_type",
 962         FT_UINT16, BASE_DEC, NULL, 0x0,
 963         "", HFILL }
 964     },
 965     { &hf_iua_status_ident,
 966       { "Status identification", "iua.status_identification",
 967         FT_UINT16, BASE_DEC, NULL, 0x0,
 968         "", HFILL }
 969     },
 970     { &hf_iua_traffic_mode_type,
 971       { "Traffic mode type", "iua.traffic_mode_type",
 972         FT_UINT32, BASE_HEX, NULL, 0x0,
 973         "", HFILL }
 974     },
 975     { &hf_iua_error_code,
 976       { "Error code", "iua.error_code",
 977         FT_UINT32, BASE_DEC, NULL, 0x0,
 978         "", HFILL }
 979     },
 980     { &hf_iua_asp_reason,
 981       { "Reason", "iua.asp_reason",
 982         FT_UINT32, BASE_HEX, NULL, 0x0,
 983         "", HFILL }
 984     },
 985     { &hf_iua_tei_status,
 986       { "TEI status", "iua.tei_status",
 987         FT_UINT32, BASE_HEX, NULL, 0x0,
 988         "", HFILL }
 989     },
 990  };
 991   /* Setup protocol subtree array */
 992   static gint *ett[] = {
 993     &ett_iua,
 994     &ett_iua_parameter,
 995     &ett_iua_dlci,
 996     &ett_iua_range,
 997   };
 998
 999   /* Register the protocol name and description */
1000   proto_iua = proto_register_protocol("ISDN Q.921-User Adaptation Layer",
1001                                       "IUA", "iua");
1002
1003   /* Required function calls to register the header fields and subtrees used */
1004   proto_register_field_array(proto_iua, hf, array_length(hf));
1005   proto_register_subtree_array(ett, array_length(ett));
1006 };
1007
1008 void
1009 proto_reg_handoff_iua(void)
1010 {
1011   dissector_handle_t iua_handle;
1012
1013   iua_handle = create_dissector_handle(dissect_iua, proto_iua);
1014   dissector_add("sctp.port", SCTP_PORT_IUA, iua_handle);
1015   dissector_add("sctp.ppi", IUA_PAYLOAD_PROTO_ID, iua_handle);
1016 }