epan/dissectors/packet-sccpmg.c

   1 /* packet-sccpmg.c
   2  * Routines for Signalling Connection Control Part (SCCP) Management dissection
   3  *
   4  * It is hopefully compliant to:
   5  *   ANSI T1.112.3-1996
   6  *   ITU-T Q.713 7/1996
   7  *   YDN 038-1997 (Chinese ITU variant)
   8  *   JT-Q714 and NTT-Q714 (Japan)
   9  *
  10  *   Note that NTT Annex E (SCCP Management Procedure (Global Title Status
  11  *   Management)) is not implemented (yet)
  12  *
  13  * Copyright 2002, Jeff Morriss <jeff.morriss.ws [AT] gmail.com>
  14  *
  15  * Wireshark - Network traffic analyzer
  16  * By Gerald Combs <gerald@wireshark.org>
  17  * Copyright 1998 Gerald Combs
  18  *
  19  * SPDX-License-Identifier: GPL-2.0-or-later
  20  */
  21
  22 #include "config.h"
  23
  24 #include <epan/packet.h>
  25 #include <epan/expert.h>
  26 #include "packet-mtp3.h"
  27
  28 #define SCCPMG_SSN 1
  29
  30 #define SCCPMG_MESSAGE_TYPE_SSA 0x01
  31 #define SCCPMG_MESSAGE_TYPE_SSP 0x02
  32 #define SCCPMG_MESSAGE_TYPE_SST 0x03
  33 #define SCCPMG_MESSAGE_TYPE_SOR 0x04
  34 #define SCCPMG_MESSAGE_TYPE_SOG 0x05
  35 /* SSC is ITU only */
  36 #define SCCPMG_MESSAGE_TYPE_SSC 0x06
  37 /* Below are ANSI only */
  38 #define SCCPMG_MESSAGE_TYPE_SBR 0xfd
  39 #define SCCPMG_MESSAGE_TYPE_SNR 0xfe
  40 #define SCCPMG_MESSAGE_TYPE_SRT 0xff
  41
  42 void proto_register_sccpmg(void);
  43 void proto_reg_handoff_sccpmg(void);
  44
  45 static dissector_handle_t sccpmg_handle;
  46
  47 /* Same as below but with names typed out */
  48 static const value_string sccpmg_message_type_values[] = {
  49         { SCCPMG_MESSAGE_TYPE_SSA,   "SubSystem Allowed" },
  50         { SCCPMG_MESSAGE_TYPE_SSP,   "SubSystem Prohibited" },
  51         { SCCPMG_MESSAGE_TYPE_SST,   "Subsystem Status Test" },
  52         { SCCPMG_MESSAGE_TYPE_SOR,   "Subsystem Out of service Request" },
  53         { SCCPMG_MESSAGE_TYPE_SOG,   "Subsystem Out of service Grant" },
  54         { SCCPMG_MESSAGE_TYPE_SSC,   "SubSystem Congested (ITU)" },
  55         { SCCPMG_MESSAGE_TYPE_SBR,   "Subsystem Backup Routing (ANSI)" },
  56         { SCCPMG_MESSAGE_TYPE_SNR,   "Subsystem Normal Routing (ANSI)" },
  57         { SCCPMG_MESSAGE_TYPE_SRT,   "Subsystem Routing status Test (ANSI)" },
  58         { 0,                       NULL } };
  59
  60 /* Same as above but in acronym for (for the Info column) */
  61 static const value_string sccpmg_message_type_acro_values[] = {
  62         { SCCPMG_MESSAGE_TYPE_SSA,   "SSA" },
  63         { SCCPMG_MESSAGE_TYPE_SSP,   "SSP" },
  64         { SCCPMG_MESSAGE_TYPE_SST,   "SST" },
  65         { SCCPMG_MESSAGE_TYPE_SOR,   "SOR" },
  66         { SCCPMG_MESSAGE_TYPE_SOG,   "SOG" },
  67         { SCCPMG_MESSAGE_TYPE_SSC,   "SSC" },
  68         { SCCPMG_MESSAGE_TYPE_SBR,   "SBR" },
  69         { SCCPMG_MESSAGE_TYPE_SNR,   "SNR" },
  70         { SCCPMG_MESSAGE_TYPE_SRT,   "SRT" },
  71         { 0,                       NULL } };
  72
  73
  74 #define SCCPMG_MESSAGE_TYPE_OFFSET 0
  75 #define SCCPMG_MESSAGE_TYPE_LENGTH 1
  76
  77 #define SCCPMG_AFFECTED_SSN_OFFSET SCCPMG_MESSAGE_TYPE_LENGTH
  78 #define SCCPMG_AFFECTED_SSN_LENGTH 1
  79
  80 #define SCCPMG_AFFECTED_PC_OFFSET (SCCPMG_AFFECTED_SSN_OFFSET + SCCPMG_AFFECTED_SSN_LENGTH)
  81 #define ITU_SCCPMG_AFFECTED_PC_LENGTH 2
  82 #define ANSI_SCCPMG_AFFECTED_PC_LENGTH 3
  83
  84 #define ITU_SCCPMG_SMI_OFFSET (SCCPMG_AFFECTED_PC_OFFSET + ITU_SCCPMG_AFFECTED_PC_LENGTH)
  85 #define ANSI_SCCPMG_SMI_OFFSET (SCCPMG_AFFECTED_PC_OFFSET + ANSI_SCCPMG_AFFECTED_PC_LENGTH)
  86 #define SCCPMG_SMI_LENGTH 1
  87 #define SCCPMG_SMI_MASK 0x3
  88
  89 #define ITU_SCCPMG_CONGESTION_OFFSET (ITU_SCCPMG_SMI_OFFSET + SCCPMG_SMI_LENGTH)
  90 #define ITU_SCCPMG_CONGESTION_LENGTH 1
  91 #define ITU_SCCPMG_CONGESTION_MASK 0x0f
  92 #define CHINESE_ITU_SCCPMG_CONGESTION_OFFSET (ANSI_SCCPMG_SMI_OFFSET + SCCPMG_SMI_LENGTH)
  93
  94 #define SCCPMG_SSN_LENGTH    1
  95
  96 /* Initialize the protocol and registered fields */
  97 static int proto_sccpmg;
  98 static int hf_sccpmg_message_type;
  99 static int hf_sccpmg_affected_ssn;
 100 static int hf_sccpmg_affected_itu_pc;
 101 static int hf_sccpmg_affected_japan_pc;
 102 static int hf_sccpmg_affected_ansi_pc;
 103 static int hf_sccpmg_affected_chinese_pc;
 104 static int hf_sccpmg_affected_pc_member;
 105 static int hf_sccpmg_affected_pc_cluster;
 106 static int hf_sccpmg_affected_pc_network;
 107 static int hf_sccpmg_smi;
 108 static int hf_sccpmg_congestion_level;
 109
 110 /* Initialize the subtree pointers */
 111 static int ett_sccpmg;
 112 static int ett_sccpmg_affected_pc;
 113
 114 static expert_field ei_sccpmg_unknown_msg;
 115
 116 static void
 117 dissect_sccpmg_affected_ssn(tvbuff_t *tvb, proto_tree *sccpmg_tree)
 118 {
 119         proto_tree_add_item(sccpmg_tree, hf_sccpmg_affected_ssn, tvb,
 120                             SCCPMG_AFFECTED_SSN_OFFSET, SCCPMG_SSN_LENGTH,
 121                             ENC_BIG_ENDIAN);
 122 }
 123
 124 static void
 125 dissect_sccpmg_affected_pc(tvbuff_t *tvb, proto_tree *sccpmg_tree)
 126 {
 127         int offset = SCCPMG_AFFECTED_PC_OFFSET;
 128
 129         if (mtp3_standard == ITU_STANDARD) {
 130                 proto_tree_add_item(sccpmg_tree, hf_sccpmg_affected_itu_pc, tvb,
 131                                     offset, ITU_PC_LENGTH, ENC_LITTLE_ENDIAN);
 132         } else if (mtp3_standard == JAPAN_STANDARD) {
 133                 proto_tree_add_item(sccpmg_tree, hf_sccpmg_affected_japan_pc,
 134                                     tvb, offset, JAPAN_PC_LENGTH, ENC_LITTLE_ENDIAN);
 135         } else /* ANSI_STANDARD and CHINESE_ITU_STANDARD */ {
 136                 int *hf_affected_pc;
 137
 138                 if (mtp3_standard == ANSI_STANDARD)
 139                 {
 140                         hf_affected_pc = &hf_sccpmg_affected_ansi_pc;
 141                 } else /* CHINESE_ITU_STANDARD */ {
 142                         hf_affected_pc = &hf_sccpmg_affected_chinese_pc;
 143                 }
 144
 145                 /* create and fill the PC tree */
 146                 dissect_mtp3_3byte_pc(tvb, offset, sccpmg_tree,
 147                                       ett_sccpmg_affected_pc, *hf_affected_pc,
 148                                       hf_sccpmg_affected_pc_network,
 149                                       hf_sccpmg_affected_pc_cluster,
 150                                       hf_sccpmg_affected_pc_member, 0, 0);
 151
 152         }
 153 }
 154
 155 static void
 156 dissect_sccpmg_smi(tvbuff_t *tvb, proto_tree *sccpmg_tree)
 157 {
 158         int offset = 0;
 159
 160         if (mtp3_standard == ITU_STANDARD || mtp3_standard == JAPAN_STANDARD)
 161                 offset = ITU_SCCPMG_SMI_OFFSET;
 162         else /* ANSI_STANDARD and CHINESE_ITU_STANDARD */
 163                 offset = ANSI_SCCPMG_SMI_OFFSET;
 164
 165         proto_tree_add_item(sccpmg_tree, hf_sccpmg_smi, tvb, offset,
 166                             SCCPMG_SMI_LENGTH, ENC_BIG_ENDIAN);
 167 }
 168
 169 static void
 170 dissect_sccpmg_congestion_level(tvbuff_t *tvb, proto_tree *sccpmg_tree)
 171 {
 172         int offset = 0;
 173
 174         if (mtp3_standard == CHINESE_ITU_STANDARD)
 175                 offset = CHINESE_ITU_SCCPMG_CONGESTION_OFFSET;
 176         else /* ITU_STANDARD or JAPAN_STANDARD */
 177                 offset = ITU_SCCPMG_CONGESTION_OFFSET;
 178
 179         proto_tree_add_item(sccpmg_tree, hf_sccpmg_congestion_level, tvb,
 180                             offset, ITU_SCCPMG_CONGESTION_LENGTH, ENC_BIG_ENDIAN);
 181 }
 182
 183 static void
 184 dissect_sccpmg_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sccpmg_tree)
 185 {
 186         uint8_t message_type;
 187
 188         /* Extract the message type;  all other processing is based on this */
 189         message_type   = tvb_get_uint8(tvb, SCCPMG_MESSAGE_TYPE_OFFSET);
 190
 191         col_add_fstr(pinfo->cinfo, COL_INFO, "%s ", val_to_str_const(message_type, sccpmg_message_type_acro_values, "Unknown"));
 192
 193         if (sccpmg_tree) {
 194                 /* add the message type to the protocol tree */
 195                 proto_tree_add_uint(sccpmg_tree, hf_sccpmg_message_type, tvb,
 196                                     SCCPMG_MESSAGE_TYPE_OFFSET,
 197                                     SCCPMG_MESSAGE_TYPE_LENGTH, message_type);
 198         }
 199
 200         switch(message_type) {
 201         case SCCPMG_MESSAGE_TYPE_SBR:
 202         case SCCPMG_MESSAGE_TYPE_SNR:
 203         case SCCPMG_MESSAGE_TYPE_SRT:
 204                 if (mtp3_standard != ANSI_STANDARD)
 205                 {
 206                         proto_tree_add_expert(sccpmg_tree, pinfo, &ei_sccpmg_unknown_msg, tvb, 0, -1);
 207                         break;
 208                 }
 209                 /* else fallthrough */
 210         case SCCPMG_MESSAGE_TYPE_SSA:
 211         case SCCPMG_MESSAGE_TYPE_SSP:
 212         case SCCPMG_MESSAGE_TYPE_SST:
 213         case SCCPMG_MESSAGE_TYPE_SOR:
 214         case SCCPMG_MESSAGE_TYPE_SOG:
 215                 dissect_sccpmg_affected_ssn(tvb, sccpmg_tree);
 216                 dissect_sccpmg_affected_pc(tvb, sccpmg_tree);
 217                 dissect_sccpmg_smi(tvb, sccpmg_tree);
 218
 219                 break;
 220         case SCCPMG_MESSAGE_TYPE_SSC:
 221                 if (mtp3_standard != ANSI_STANDARD)
 222                 {
 223                         dissect_sccpmg_affected_ssn(tvb, sccpmg_tree);
 224                         dissect_sccpmg_affected_pc(tvb, sccpmg_tree);
 225                         dissect_sccpmg_smi(tvb, sccpmg_tree);
 226                         dissect_sccpmg_congestion_level(tvb, sccpmg_tree);
 227                 }
 228                 /* else fallthrough */
 229
 230         default:
 231                 proto_tree_add_expert(sccpmg_tree, pinfo, &ei_sccpmg_unknown_msg, tvb, 0, -1);
 232         }
 233 }
 234
 235 static int
 236 dissect_sccpmg(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
 237 {
 238         proto_item *sccpmg_item;
 239         proto_tree *sccpmg_tree = NULL;
 240
 241         /* Make entry in the Protocol column on summary display */
 242         switch(mtp3_standard) {
 243         case ITU_STANDARD:
 244                 col_set_str(pinfo->cinfo, COL_PROTOCOL, "SCCPMG (Int. ITU)");
 245                 break;
 246         case ANSI_STANDARD:
 247                 col_set_str(pinfo->cinfo, COL_PROTOCOL, "SCCPMG (ANSI)");
 248                 break;
 249         case CHINESE_ITU_STANDARD:
 250                 col_set_str(pinfo->cinfo, COL_PROTOCOL, "SCCPMG (Chin. ITU)");
 251                 break;
 252         };
 253
 254         /* In the interest of speed, if "tree" is NULL, don't do any work not
 255            necessary to generate protocol tree items. */
 256         if (tree) {
 257                 /* create the sccpmg protocol tree */
 258                 sccpmg_item = proto_tree_add_item(tree, proto_sccpmg, tvb, 0,
 259                                                   -1, ENC_NA);
 260                 sccpmg_tree = proto_item_add_subtree(sccpmg_item, ett_sccpmg);
 261         }
 262
 263         /* dissect the message */
 264         dissect_sccpmg_message(tvb, pinfo, sccpmg_tree);
 265         return tvb_captured_length(tvb);
 266 }
 267
 268 /* Register the protocol with Wireshark */
 269 void
 270 proto_register_sccpmg(void)
 271 {
 272         /* Setup list of header fields */
 273         static hf_register_info hf[] = {
 274           { &hf_sccpmg_message_type,
 275             { "Message Type", "sccpmg.message_type",
 276               FT_UINT8, BASE_HEX, VALS(sccpmg_message_type_values), 0x0,
 277               NULL, HFILL}},
 278           { &hf_sccpmg_affected_ssn,
 279             { "Affected SubSystem Number", "sccpmg.ssn",
 280               FT_UINT8, BASE_DEC, NULL, 0x0,
 281               NULL, HFILL}},
 282           { &hf_sccpmg_affected_itu_pc,
 283             { "Affected Point Code", "sccpmg.pc",
 284               FT_UINT16, BASE_DEC, NULL, ITU_PC_MASK,
 285               NULL, HFILL}},
 286           { &hf_sccpmg_affected_japan_pc,
 287             { "Affected Point Code", "sccpmg.pc",
 288               FT_UINT16, BASE_DEC, NULL, 0x0,
 289               NULL, HFILL}},
 290           { &hf_sccpmg_affected_ansi_pc,
 291             { "Affected Point Code", "sccpmg.ansi_pc",
 292               FT_STRING, BASE_NONE, NULL, 0x0,
 293               NULL, HFILL}},
 294           { &hf_sccpmg_affected_chinese_pc,
 295             { "Affected Point Code", "sccpmg.chinese_pc",
 296               FT_STRING, BASE_NONE, NULL, 0x0,
 297               NULL, HFILL}},
 298           { &hf_sccpmg_affected_pc_network,
 299             { "Affected PC Network", "sccpmg.network",
 300               FT_UINT24, BASE_DEC, NULL, ANSI_NETWORK_MASK,
 301               NULL, HFILL}},
 302           { &hf_sccpmg_affected_pc_cluster,
 303             { "Affected PC Cluster", "sccpmg.cluster",
 304               FT_UINT24, BASE_DEC, NULL, ANSI_CLUSTER_MASK,
 305               NULL, HFILL}},
 306           { &hf_sccpmg_affected_pc_member,
 307             { "Affected PC Member", "sccpmg.member",
 308               FT_UINT24, BASE_DEC, NULL, ANSI_MEMBER_MASK,
 309               NULL, HFILL}},
 310           { &hf_sccpmg_smi,
 311             { "Subsystem Multiplicity Indicator", "sccpmg.smi",
 312               FT_UINT8, BASE_DEC, NULL, SCCPMG_SMI_MASK,
 313               NULL, HFILL}},
 314           { &hf_sccpmg_congestion_level,
 315             { "SCCP Congestion Level (ITU)", "sccpmg.congestion",
 316               FT_UINT8, BASE_DEC, NULL, ITU_SCCPMG_CONGESTION_MASK,
 317               NULL, HFILL}}
 318         };
 319
 320         /* Setup protocol subtree array */
 321         static int *ett[] = {
 322                 &ett_sccpmg,
 323                 &ett_sccpmg_affected_pc
 324         };
 325
 326         static ei_register_info ei[] = {
 327                 { &ei_sccpmg_unknown_msg, { "sccpmg.unknown_msg", PI_UNDECODED, PI_WARN, "Unknown message", EXPFILL }},
 328         };
 329
 330         expert_module_t* expert_sccpmg;
 331
 332         /* Register the protocol name and description */
 333         proto_sccpmg = proto_register_protocol("Signalling Connection Control Part Management",
 334                                                "SCCPMG", "sccpmg");
 335
 336         /* Required function calls to register the header fields and subtrees
 337            used */
 338         proto_register_field_array(proto_sccpmg, hf, array_length(hf));
 339         proto_register_subtree_array(ett, array_length(ett));
 340         expert_sccpmg = expert_register_protocol(proto_sccpmg);
 341         expert_register_field_array(expert_sccpmg, ei, array_length(ei));
 342
 343         /* Register the dissector handle */
 344         sccpmg_handle = register_dissector("sccpmg", dissect_sccpmg, proto_sccpmg);
 345 }
 346
 347 void
 348 proto_reg_handoff_sccpmg(void)
 349 {
 350         /* Register for SCCP SSN=1 messages */
 351         dissector_add_uint("sccp.ssn", SCCPMG_SSN, sccpmg_handle);
 352 }
 353
 354 /*
 355  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 356  *
 357  * Local variables:
 358  * c-basic-offset: 8
 359  * tab-width: 8
 360  * indent-tabs-mode: t
 361  * End:
 362  *
 363  * vi: set shiftwidth=8 tabstop=8 noexpandtab:
 364  * :indentSize=8:tabSize=8:noTabs=false:
 365  */