/* packet-sccp.c

 * Routines for Signalling Connection Control Part (SCCP) dissection

 *

 * It is hopefully compliant to:

 *   ANSI T1.112.3-2001

 *   ITU-T Q.713 7/1996

 *   YDN 038-1997 (Chinese ITU variant)

 *   JT-Q713 and NTT-Q713 (Japan)

 *

 *   Note that Japan-specific GTT is incomplete; in particular, the specific

 *   TTs that are defined in TTC and NTT are not decoded in detail.

 *

 * Copyright 2002, Jeff Morriss <jeff.morriss.ws [AT] gmail.com>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * Copied from packet-m2pa.c

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/prefs.h>

#include <epan/reassemble.h>

#include <epan/address_types.h>

#include <epan/asn1.h>

#include <epan/uat.h>

#include <epan/expert.h>

#include <epan/tap.h>

#include <epan/to_str.h>

#include <epan/decode_as.h>

#include <epan/proto_data.h>

#include <wiretap/wtap.h>

#include <wsutil/str_util.h>

#include "packet-mtp3.h"

#include "packet-tcap.h"

#include "packet-sccp.h"

#include "packet-e164.h"

#include "packet-e212.h"

/* function prototypes */

void proto_register_sccp(void);

void proto_reg_handoff_sccp(void);

static Standard_Type decode_mtp3_standard;

#define SCCP_MSG_TYPE_OFFSET 0

#define SCCP_MSG_TYPE_LENGTH 1

#define POINTER_LENGTH       1

#define POINTER_LENGTH_LONG  2

/* Same as below but with names typed out */

static const value_string sccp_message_type_values[] = {

  { SCCP_MSG_TYPE_CR,           "Connection Request" },

  { SCCP_MSG_TYPE_CC,           "Connection Confirm" },

  { SCCP_MSG_TYPE_CREF,         "Connection Refused" },

  { SCCP_MSG_TYPE_RLSD,         "Released" },

  { SCCP_MSG_TYPE_RLC,          "Release Complete" },

  { SCCP_MSG_TYPE_DT1,          "Data Form 1" },

  { SCCP_MSG_TYPE_DT2,          "Data Form 2" },

  { SCCP_MSG_TYPE_AK,           "Data Acknowledgement" },

  { SCCP_MSG_TYPE_UDT,          "Unitdata" },

  { SCCP_MSG_TYPE_UDTS,         "Unitdata Service" },

  { SCCP_MSG_TYPE_ED,           "Expedited Data" },

  { SCCP_MSG_TYPE_EA,           "Expedited Data Acknowledgement" },

  { SCCP_MSG_TYPE_RSR,          "Reset Request" },

  { SCCP_MSG_TYPE_RSC,          "Reset Confirmation" },

  { SCCP_MSG_TYPE_ERR,          "Error" },

  { SCCP_MSG_TYPE_IT,           "Inactivity Timer" },

  { SCCP_MSG_TYPE_XUDT,         "Extended Unitdata" },

  { SCCP_MSG_TYPE_XUDTS,        "Extended Unitdata Service" },

  { SCCP_MSG_TYPE_LUDT,         "Long Unitdata" },

  { SCCP_MSG_TYPE_LUDTS,        "Long Unitdata Service" },

  { 0,                          NULL } };

/* Same as above but in acronym form (for the Info column) */

const value_string sccp_message_type_acro_values[] = {

  { SCCP_MSG_TYPE_CR,           "CR" },

  { SCCP_MSG_TYPE_CC,           "CC" },

  { SCCP_MSG_TYPE_CREF,         "CREF" },

  { SCCP_MSG_TYPE_RLSD,         "RLSD" },

  { SCCP_MSG_TYPE_RLC,          "RLC" },

  { SCCP_MSG_TYPE_DT1,          "DT1" },

  { SCCP_MSG_TYPE_DT2,          "DT2" },

  { SCCP_MSG_TYPE_AK,           "AK" },

  { SCCP_MSG_TYPE_UDT,          "UDT" },

  { SCCP_MSG_TYPE_UDTS,         "UDTS" },

  { SCCP_MSG_TYPE_ED,           "ED" },

  { SCCP_MSG_TYPE_EA,           "EA" },

  { SCCP_MSG_TYPE_RSR,          "RSR" },

  { SCCP_MSG_TYPE_RSC,          "RSC" },

  { SCCP_MSG_TYPE_ERR,          "ERR" },

  { SCCP_MSG_TYPE_IT,           "IT" },

  { SCCP_MSG_TYPE_XUDT,         "XUDT" },

  { SCCP_MSG_TYPE_XUDTS,        "XUDTS" },

  { SCCP_MSG_TYPE_LUDT,         "LUDT" },

  { SCCP_MSG_TYPE_LUDTS,        "LUDTS" },

  { 0,                          NULL } };

#define PARAMETER_LENGTH_LENGTH                 1

#define PARAMETER_LONG_DATA_LENGTH_LENGTH       2

#define PARAMETER_TYPE_LENGTH                   1

#define PARAMETER_END_OF_OPTIONAL_PARAMETERS    0x00

#define PARAMETER_DESTINATION_LOCAL_REFERENCE   0x01

#define PARAMETER_SOURCE_LOCAL_REFERENCE        0x02

#define PARAMETER_CALLED_PARTY_ADDRESS          0x03

#define PARAMETER_CALLING_PARTY_ADDRESS         0x04

#define PARAMETER_CLASS                         0x05

#define PARAMETER_SEGMENTING_REASSEMBLING       0x06

#define PARAMETER_RECEIVE_SEQUENCE_NUMBER       0x07

#define PARAMETER_SEQUENCING_SEGMENTING         0x08

#define PARAMETER_CREDIT                        0x09

#define PARAMETER_RELEASE_CAUSE                 0x0a

#define PARAMETER_RETURN_CAUSE                  0x0b

#define PARAMETER_RESET_CAUSE                   0x0c

#define PARAMETER_ERROR_CAUSE                   0x0d

#define PARAMETER_REFUSAL_CAUSE                 0x0e

#define PARAMETER_DATA                          0x0f

#define PARAMETER_SEGMENTATION                  0x10

#define PARAMETER_HOP_COUNTER                   0x11

/* Importance is ITU only */

#define PARAMETER_IMPORTANCE                    0x12

#define PARAMETER_LONG_DATA                     0x13

/* ISNI is ANSI only */

#define PARAMETER_ISNI                          0xfa

static const value_string sccp_parameter_values[] = {

  { PARAMETER_END_OF_OPTIONAL_PARAMETERS,       "End of Optional Parameters" },

  { PARAMETER_DESTINATION_LOCAL_REFERENCE,      "Destination Local Reference" },

  { PARAMETER_SOURCE_LOCAL_REFERENCE,           "Source Local Reference" },

  { PARAMETER_CALLED_PARTY_ADDRESS,             "Called Party Address" },

  { PARAMETER_CALLING_PARTY_ADDRESS,            "Calling Party Address" },

  { PARAMETER_CLASS,                            "Protocol Class" },

  { PARAMETER_SEGMENTING_REASSEMBLING,          "Segmenting/Reassembling" },

  { PARAMETER_RECEIVE_SEQUENCE_NUMBER,          "Receive Sequence Number" },

  { PARAMETER_SEQUENCING_SEGMENTING,            "Sequencing/Segmenting" },

  { PARAMETER_CREDIT,                           "Credit" },

  { PARAMETER_RELEASE_CAUSE,                    "Release Cause" },

  { PARAMETER_RETURN_CAUSE,                     "Return Cause" },

  { PARAMETER_RESET_CAUSE,                      "Reset Cause" },

  { PARAMETER_ERROR_CAUSE,                      "Error Cause" },

  { PARAMETER_REFUSAL_CAUSE,                    "Refusal Cause" },

  { PARAMETER_DATA,                             "Data" },

  { PARAMETER_SEGMENTATION,                     "Segmentation" },

  { PARAMETER_HOP_COUNTER,                      "Hop Counter" },

  { PARAMETER_IMPORTANCE,                       "Importance (ITU)" },

  { PARAMETER_LONG_DATA,                        "Long Data" },

  { PARAMETER_ISNI,                             "Intermediate Signaling Network Identification (ANSI)" },

  { 0,                                           NULL } };

#define END_OF_OPTIONAL_PARAMETERS_LENGTH       1

#define DESTINATION_LOCAL_REFERENCE_LENGTH      3

#define SOURCE_LOCAL_REFERENCE_LENGTH           3

#define PROTOCOL_CLASS_LENGTH                   1

#define RECEIVE_SEQUENCE_NUMBER_LENGTH          1

#define CREDIT_LENGTH                           1

#define RELEASE_CAUSE_LENGTH                    1

#define RETURN_CAUSE_LENGTH                     1

#define RESET_CAUSE_LENGTH                      1

#define ERROR_CAUSE_LENGTH                      1

#define REFUSAL_CAUSE_LENGTH                    1

#define HOP_COUNTER_LENGTH                      1

#define IMPORTANCE_LENGTH                       1

/* Parts of the Called and Calling Address parameters */

/* Address Indicator */

#define ADDRESS_INDICATOR_LENGTH        1

#define ITU_RESERVED_MASK               0x80

#define ANSI_NATIONAL_MASK              0x80

#define ROUTING_INDICATOR_MASK          0x40

#define GTI_MASK                        0x3C

#define GTI_SHIFT                       2

#define ITU_SSN_INDICATOR_MASK          0x02

#define ITU_PC_INDICATOR_MASK           0x01

#define ANSI_PC_INDICATOR_MASK          0x02

#define ANSI_SSN_INDICATOR_MASK         0x01

static const value_string sccp_ansi_national_indicator_values[] = {

  { 0x0,  "Address coded to International standard" },

  { 0x1,  "Address coded to National standard" },

  { 0,    NULL } };

#define ROUTE_ON_GT             0x0

#define ROUTE_ON_SSN            0x1

#define ROUTING_INDICATOR_SHIFT 6

static const value_string sccp_routing_indicator_values[] = {

  { ROUTE_ON_GT,  "Route on GT" },

  { ROUTE_ON_SSN, "Route on SSN" },

  { 0,            NULL } };

#define AI_GTI_NO_GT                    0x0

#define ITU_AI_GTI_NAI                  0x1

#define AI_GTI_TT                       0x2

#define ITU_AI_GTI_TT_NP_ES             0x3

#define ITU_AI_GTI_TT_NP_ES_NAI 0x4

static const value_string sccp_itu_global_title_indicator_values[] = {

  { AI_GTI_NO_GT,               "No Global Title" },

  { ITU_AI_GTI_NAI,             "Nature of Address Indicator only" },

  { AI_GTI_TT,                  "Translation Type only" },

  { ITU_AI_GTI_TT_NP_ES,        "Translation Type, Numbering Plan, and Encoding Scheme included" },

  { ITU_AI_GTI_TT_NP_ES_NAI,    "Translation Type, Numbering Plan, Encoding Scheme, and Nature of Address Indicator included" },

  { 0,                          NULL } };

/* #define AI_GTI_NO_GT         0x0 */

#define ANSI_AI_GTI_TT_NP_ES    0x1

/* #define AI_GTI_TT            0x2 */

static const value_string sccp_ansi_global_title_indicator_values[] = {

  { AI_GTI_NO_GT,               "No Global Title" },

  { ANSI_AI_GTI_TT_NP_ES,       "Translation Type, Numbering Plan, and Encoding Scheme included" },

  { AI_GTI_TT,                  "Translation Type only" },

  { 0,                          NULL } };

static const value_string sccp_ai_pci_values[] = {

  { 0x1,  "Point Code present" },

  { 0x0,  "Point Code not present" },

  { 0,    NULL } };

static const value_string sccp_ai_ssni_values[] = {

  { 0x1,  "SSN present" },

  { 0x0,  "SSN not present" },

  { 0,    NULL } };

#define ADDRESS_SSN_LENGTH      1

#define INVALID_SSN             0xff

/* Some values from 3GPP TS 23.003 */

/*  Japan TTC and NTT define a lot of SSNs, some of which conflict with

 *  these.  They are not added for now.

 */

static const value_string sccp_ssn_values[] = {

  { 0x00,  "SSN not known/not used" },

  { 0x01,  "SCCP management" },

  { 0x02,  "Reserved for ITU-T allocation" },

  { 0x03,  "ISDN User Part" },

  { 0x04,  "OMAP (Operation, Maintenance, and Administration Part)" },

  { 0x05,  "MAP (Mobile Application Part)" },

  { 0x06,  "HLR (Home Location Register)" },

  { 0x07,  "VLR (Visitor Location Register)" },

  { 0x08,  "MSC (Mobile Switching Center)" },

  { 0x09,  "EIC/EIR (Equipment Identifier Center/Equipment Identification Register)" },

  { 0x0a,  "AUC/AC (Authentication Center)" },

  { 0x0b,  "ISDN supplementary services (ITU only)" },

  { 0x0c,  "Reserved for international use (ITU only)" },

  { 0x0d,  "Broadband ISDN edge-to-edge applications (ITU only)" },

  { 0x0e,  "TC test responder (ITU only)" },

  /* The following national network subsystem numbers have been allocated for use within and

   * between GSM/UMTS networks:

   */

  { 0x8e,  "RANAP" },

  { 0x8f,  "RNSAP" },

  { 0x91,  "GMLC(MAP)" },

  { 0x92,  "CAP" },

  { 0x93,  "gsmSCF (MAP) or IM-SSF (MAP) or Presence Network Agent" },

  { 0x94,  "SIWF (MAP)" },

  { 0x95,  "SGSN (MAP)" },

  { 0x96,  "GGSN (MAP)" },

  /* The following national network subsystem numbers have been allocated for use within GSM/UMTS networks:*/

  { 0xf8,  "CSS (MAP)" },

  { 0xf9,  "PCAP" },

  { 0xfa,  "BSC (BSSAP-LE)" },

  { 0xfb,  "MSC (BSSAP-LE)" },

  { 0xfc,  "IOS or SMLC (BSSAP-LE)" },

  { 0xfd,  "BSS O&M (A interface)" },

  { 0xfe,  "BSSAP/BSAP" },

  { 0,     NULL } };

/* * * * * * * * * * * * * * * * *

 * Global Title: ITU GTI == 0001 *

 * * * * * * * * * * * * * * * * */

#define GT_NAI_MASK 0x7F

#define GT_NAI_LENGTH 1

#define GT_NAI_UNKNOWN                  0x00

#define GT_NAI_SUBSCRIBER_NUMBER        0x01

#define GT_NAI_RESERVED_NATIONAL        0x02

#define GT_NAI_NATIONAL_SIG_NUM         0x03

#define GT_NAI_INTERNATIONAL_NUM        0x04

static const value_string sccp_nai_values[] = {

  { GT_NAI_UNKNOWN,             "NAI unknown" },

  { GT_NAI_SUBSCRIBER_NUMBER,   "Subscriber Number" },

  { GT_NAI_RESERVED_NATIONAL,   "Reserved for national use" },

  { GT_NAI_NATIONAL_SIG_NUM,    "National significant number" },

  { GT_NAI_INTERNATIONAL_NUM,   "International number" },

  { 0,                          NULL } };

#define GT_OE_MASK 0x80

#define GT_OE_EVEN 0

#define GT_OE_ODD  1

static const value_string sccp_oe_values[] = {

  { GT_OE_EVEN, "Even number of address signals" },

  { GT_OE_ODD,  "Odd number of address signals" },

  { 0,          NULL } };

const value_string sccp_address_signal_values[] = {

  { 0,  "0" },

  { 1,  "1" },

  { 2,  "2" },

  { 3,  "3" },

  { 4,  "4" },

  { 5,  "5" },

  { 6,  "6" },

  { 7,  "7" },

  { 8,  "8" },

  { 9,  "9" },

  { 10, "(spare)" },

  { 11, "11" },

  { 12, "12" },

  { 13, "(spare)" },

  { 14, "(spare)" },

  { 15, "ST" },

  { 0,  NULL } };

/* * * * * * * * * * * * * * * * * * * * *

 * Global Title: ITU and ANSI GTI == 0010 *

 * * * * * * * * * * * * * * * * * * * * */

#define GT_TT_LENGTH 1

/* * * * * * * * * * * * * * * * * * * * * * * * * *

 * Global Title: ITU GTI == 0011, ANSI GTI == 0001 *

 * * * * * * * * * * * * * * * * * * * * * * * * * */

#define GT_NP_MASK              0xf0

#define GT_NP_SHIFT             4

#define GT_NP_ES_LENGTH         1

#define GT_NP_UNKNOWN           0x00

#define GT_NP_ISDN              0x01

#define GT_NP_GENERIC_RESERVED  0x02

#define GT_NP_DATA              0x03

#define GT_NP_TELEX             0x04

#define GT_NP_MARITIME_MOBILE   0x05

#define GT_NP_LAND_MOBILE       0x06

#define GT_NP_ISDN_MOBILE       0x07

#define GT_NP_PRIVATE_NETWORK   0x0e

#define GT_NP_RESERVED          0x0f

static const value_string sccp_np_values[] = {

  { GT_NP_UNKNOWN,              "Unknown" },

  { GT_NP_ISDN,                 "ISDN/telephony" },

  { GT_NP_GENERIC_RESERVED,     "Generic (ITU)/Reserved (ANSI)" },

  { GT_NP_DATA,                 "Data" },

  { GT_NP_TELEX,                "Telex" },

  { GT_NP_MARITIME_MOBILE,      "Maritime mobile" },

  { GT_NP_LAND_MOBILE,          "Land mobile" },

  { GT_NP_ISDN_MOBILE,          "ISDN/mobile" },

  { GT_NP_PRIVATE_NETWORK,      "Private network or network-specific" },

  { GT_NP_RESERVED,             "Reserved" },

  { 0,                          NULL } };

#define GT_ES_MASK     0x0f

#define GT_ES_UNKNOWN  0x0

#define GT_ES_BCD_ODD  0x1

#define GT_ES_BCD_EVEN 0x2

#define GT_ES_NATIONAL 0x3

#define GT_ES_RESERVED 0xf

static const value_string sccp_es_values[] = {

  { GT_ES_UNKNOWN,      "Unknown" },

  { GT_ES_BCD_ODD,      "BCD, odd number of digits" },

  { GT_ES_BCD_EVEN,     "BCD, even number of digits" },

  { GT_ES_NATIONAL,     "National specific" },

  { GT_ES_RESERVED,     "Reserved (ITU)/Spare (ANSI)" },

  { 0,                  NULL } };

/* Address signals above */

/* * * * * * * * * * * * * * * * *

 * Global Title: ITU GTI == 0100 *

 * * * * * * * * * * * * * * * * */

/* NP above */

/* ES above */

/* NAI above */

/* Address signals above */

#define CLASS_CLASS_MASK                0xf

#define CLASS_SPARE_HANDLING_MASK       0xf0

#define CLASS_SPARE_HANDLING_SHIFT      4

static const value_string sccp_class_handling_values [] = {

  { 0x0,  "No special options" },

  { 0x8,  "Return message on error" },

  { 0,    NULL } };

#define SEGMENTING_REASSEMBLING_LENGTH 1

#define SEGMENTING_REASSEMBLING_MASK   0x01

#define NO_MORE_DATA 0

#define MORE_DATA    1

/* This is also used by sequencing-segmenting parameter */

static const value_string sccp_segmenting_reassembling_values [] = {

  { NO_MORE_DATA,       "No more data" },

  { MORE_DATA,          "More data" },

  { 0,                  NULL } };

#define RECEIVE_SEQUENCE_NUMBER_LENGTH          1

#define RSN_MASK                                0xfe

#define SEQUENCING_SEGMENTING_LENGTH            2

#define SEQUENCING_SEGMENTING_SSN_LENGTH        1

#define SEQUENCING_SEGMENTING_RSN_LENGTH        1

#define SEND_SEQUENCE_NUMBER_MASK               0xfe

#define RECEIVE_SEQUENCE_NUMBER_MASK            0xfe

#define SEQUENCING_SEGMENTING_MORE_MASK         0x01

#define CREDIT_LENGTH 1

#define RELEASE_CAUSE_LENGTH 1

const value_string sccp_release_cause_values [] = {

  { 0x00,  "End user originated" },

  { 0x01,  "End user congestion" },

  { 0x02,  "End user failure" },

  { 0x03,  "SCCP user originated" },

  { 0x04,  "Remote procedure error" },

  { 0x05,  "Inconsistent connection data" },

  { 0x06,  "Access failure" },

  { 0x07,  "Access congestion" },

  { 0x08,  "Subsystem failure" },

  { 0x09,  "Subsystem congestion" },

  { 0x0a,  "MTP failure" },

  { 0x0b,  "Network congestion" },

  { 0x0c,  "Expiration of reset timer" },

  { 0x0d,  "Expiration of receive inactivity timer" },

  { 0x0e,  "Reserved" },

  { 0x0f,  "Unqualified" },

  { 0x10,  "SCCP failure (ITU only)" },

  { 0,     NULL } };

#define RETURN_CAUSE_LENGTH 1

const value_string sccp_return_cause_values [] = {

  { 0x00,  "No translation for an address of such nature" },

  { 0x01,  "No translation for this specific address" },

  { 0x02,  "Subsystem congestion" },

  { 0x03,  "Subsystem failure" },

  { 0x04,  "Unequipped failure" },

  { 0x05,  "MTP failure" },

  { 0x06,  "Network congestion" },

  { 0x07,  "Unqualified" },

  { 0x08,  "Error in message transport" },

  { 0x09,  "Error in local processing" },

  { 0x0a,  "Destination cannot perform reassembly" },

  { 0x0b,  "SCCP failure" },

  { 0x0c,  "Hop counter violation" },

  { 0x0d,  "Segmentation not supported" },

  { 0x0e,  "Segmentation failure" },

  { 0xf7,  "Message change failure (ANSI only)" },

  { 0xf8,  "Invalid INS routing request (ANSI only)" },

  { 0xf9,  "Invalid ISNI routing request (ANSI only)"},

  { 0xfa,  "Unauthorized message (ANSI only)" },

  { 0xfb,  "Message incompatibility (ANSI only)" },

  { 0xfc,  "Cannot perform ISNI constrained routing (ANSI only)" },

  { 0xfd,  "Redundant ISNI constrained routing (ANSI only)" },

  { 0xfe,  "Unable to perform ISNI identification (ANSI only)" },

  { 0,     NULL } };

#define RESET_CAUSE_LENGTH 1

const value_string sccp_reset_cause_values [] = {

  { 0x00,  "End user originated" },

  { 0x01,  "SCCP user originated" },

  { 0x02,  "Message out of order - incorrect send sequence number" },

  { 0x03,  "Message out of order - incorrect receive sequence number" },

  { 0x04,  "Remote procedure error - message out of window" },

  { 0x05,  "Remote procedure error - incorrect send sequence number after (re)initialization" },

  { 0x06,  "Remote procedure error - general" },

  { 0x07,  "Remote end user operational" },

  { 0x08,  "Network operational" },

  { 0x09,  "Access operational" },

  { 0x0a,  "Network congestion" },

  { 0x0b,  "Reserved (ITU)/Not obtainable (ANSI)" },

  { 0x0c,  "Unqualified" },

  { 0,     NULL } };

#define ERROR_CAUSE_LENGTH 1

const value_string sccp_error_cause_values [] = {

  { 0x00,  "Local Reference Number (LRN) mismatch - unassigned destination LRN" },

  { 0x01,  "Local Reference Number (LRN) mismatch - inconsistent source LRN" },

  { 0x02,  "Point code mismatch" },

  { 0x03,  "Service class mismatch" },

  { 0x04,  "Unqualified" },

  { 0,     NULL } };

#define REFUSAL_CAUSE_LENGTH 1

const value_string sccp_refusal_cause_values [] = {

  { 0x00,  "End user originated" },

  { 0x01,  "End user congestion" },

  { 0x02,  "End user failure" },

  { 0x03,  "SCCP user originated" },

  { 0x04,  "Destination address unknown" },

  { 0x05,  "Destination inaccessible" },

  { 0x06,  "Network resource - QOS not available/non-transient" },

  { 0x07,  "Network resource - QOS not available/transient" },

  { 0x08,  "Access failure" },

  { 0x09,  "Access congestion" },

  { 0x0a,  "Subsystem failure" },

  { 0x0b,  "Subsystem congestion" },

  { 0x0c,  "Expiration of connection establishment timer" },

  { 0x0d,  "Incompatible user data" },

  { 0x0e,  "Reserved" },

  { 0x0f,  "Unqualified" },

  { 0x10,  "Hop counter violation" },

  { 0x11,  "SCCP failure (ITU only)" },

  { 0x12,  "No translation for an address of such nature" },

  { 0x13,  "Unequipped user" },

  { 0,     NULL } };

#define SEGMENTATION_LENGTH             4

#define SEGMENTATION_FIRST_SEGMENT_MASK 0x80

#define SEGMENTATION_CLASS_MASK         0x40

#define SEGMENTATION_SPARE_MASK         0x30

#define SEGMENTATION_REMAINING_MASK     0x0f

static const value_string sccp_segmentation_first_segment_values [] = {

  { 1,  "First segment" },

  { 0,  "Not first segment" },

  { 0,  NULL } };

static const value_string sccp_segmentation_class_values [] = {

  { 0,  "Class 0 selected" },

  { 1,  "Class 1 selected" },

  { 0,  NULL } };

#define HOP_COUNTER_LENGTH 1

#define IMPORTANCE_LENGTH               1

#define IMPORTANCE_IMPORTANCE_MASK      0x7

#define ANSI_ISNI_ROUTING_CONTROL_LENGTH 1

#define ANSI_ISNI_MI_MASK                0x01

#define ANSI_ISNI_IRI_MASK               0x06

#define ANSI_ISNI_RES_MASK               0x08

#define ANSI_ISNI_TI_MASK                0x10

#define ANSI_ISNI_TI_SHIFT               4

#define ANSI_ISNI_COUNTER_MASK           0xe0

#define ANSI_ISNI_NETSPEC_MASK           0x03

static const value_string sccp_isni_mark_for_id_values [] = {

  { 0x0,  "Do not identify networks" },

  { 0x1,  "Identify networks" },

  { 0,    NULL } };

static const value_string sccp_isni_iri_values [] = {

  { 0x0,  "Neither constrained nor suggested ISNI routing" },

  { 0x1,  "Constrained ISNI routing" },

  { 0x2,  "Reserved for suggested ISNI routing" },

  { 0x3,  "Spare" },

  { 0,    NULL } };

#define ANSI_ISNI_TYPE_0 0x0

#define ANSI_ISNI_TYPE_1 0x1

static const value_string sccp_isni_ti_values [] = {

  { ANSI_ISNI_TYPE_0,   "Type zero ISNI parameter format" },

  { ANSI_ISNI_TYPE_1,   "Type one ISNI parameter format" },

  { 0,                  NULL } };

/* Laded from e212 hf*/

static int hf_assoc_imsi;

/* Initialize the protocol and registered fields */

static int proto_sccp;

static int hf_sccp_message_type;

static int hf_sccp_variable_pointer1;

static int hf_sccp_variable_pointer2;

static int hf_sccp_variable_pointer3;

static int hf_sccp_optional_pointer;

static int hf_sccp_param_length;

static int hf_sccp_ssn;

static int hf_sccp_gt_digits;

/* Called Party address */

static int hf_sccp_called_ansi_national_indicator;

static int hf_sccp_called_itu_natl_use_bit;

static int hf_sccp_called_routing_indicator;

static int hf_sccp_called_itu_global_title_indicator;

static int hf_sccp_called_ansi_global_title_indicator;

static int hf_sccp_called_itu_ssn_indicator;

static int hf_sccp_called_itu_point_code_indicator;

static int hf_sccp_called_ansi_ssn_indicator;

static int hf_sccp_called_ansi_point_code_indicator;

static int hf_sccp_called_ssn;

static int hf_sccp_called_pc_member;

static int hf_sccp_called_pc_cluster;

static int hf_sccp_called_pc_network;

static int hf_sccp_called_ansi_pc;

static int hf_sccp_called_chinese_pc;

static int hf_sccp_called_itu_pc;

static int hf_sccp_called_japan_pc;

static int hf_sccp_called_gt_nai;

static int hf_sccp_called_gt_oe;

static int hf_sccp_called_gt_tt;

static int hf_sccp_called_gt_np;

static int hf_sccp_called_gt_es;

static int hf_sccp_called_gt_digits;

static int hf_sccp_called_gt_digits_length;

/* Calling party address */

static int hf_sccp_calling_ansi_national_indicator;

static int hf_sccp_calling_itu_natl_use_bit;

static int hf_sccp_calling_routing_indicator;

static int hf_sccp_calling_itu_global_title_indicator;

static int hf_sccp_calling_ansi_global_title_indicator;

static int hf_sccp_calling_itu_ssn_indicator;

static int hf_sccp_calling_itu_point_code_indicator;

static int hf_sccp_calling_ansi_ssn_indicator;

static int hf_sccp_calling_ansi_point_code_indicator;

static int hf_sccp_calling_ssn;

static int hf_sccp_calling_pc_member;

static int hf_sccp_calling_pc_cluster;

static int hf_sccp_calling_pc_network;

static int hf_sccp_calling_ansi_pc;

static int hf_sccp_calling_chinese_pc;

static int hf_sccp_calling_itu_pc;

static int hf_sccp_calling_japan_pc;

static int hf_sccp_calling_gt_nai;

static int hf_sccp_calling_gt_oe;

static int hf_sccp_calling_gt_tt;

static int hf_sccp_calling_gt_np;

static int hf_sccp_calling_gt_es;

static int hf_sccp_calling_gt_digits;

static int hf_sccp_calling_gt_digits_length;

/* Other parameter values */

static int hf_sccp_dlr;

static int hf_sccp_slr;

static int hf_sccp_lr;

static int hf_sccp_class;

static int hf_sccp_handling;

static int hf_sccp_more;

static int hf_sccp_rsn;

static int hf_sccp_sequencing_segmenting_ssn;

static int hf_sccp_sequencing_segmenting_rsn;

static int hf_sccp_sequencing_segmenting_more;

static int hf_sccp_credit;

static int hf_sccp_release_cause;

static int hf_sccp_return_cause;

static int hf_sccp_reset_cause;

static int hf_sccp_error_cause;

static int hf_sccp_refusal_cause;

static int hf_sccp_segmentation_first;

static int hf_sccp_segmentation_class;

static int hf_sccp_segmentation_remaining;

static int hf_sccp_segmentation_slr;

static int hf_sccp_hop_counter;

static int hf_sccp_importance;

static int hf_sccp_ansi_isni_mi;

static int hf_sccp_ansi_isni_iri;

static int hf_sccp_ansi_isni_ti;

static int hf_sccp_ansi_isni_netspec;

static int hf_sccp_ansi_isni_counter;

static int hf_sccp_ansi_isni_network;

static int hf_sccp_ansi_isni_cluster;

static int hf_sccp_xudt_msg_fragments;

static int hf_sccp_xudt_msg_fragment;

static int hf_sccp_xudt_msg_fragment_overlap;

static int hf_sccp_xudt_msg_fragment_overlap_conflicts;

static int hf_sccp_xudt_msg_fragment_multiple_tails;

static int hf_sccp_xudt_msg_fragment_too_long_fragment;

static int hf_sccp_xudt_msg_fragment_error;

static int hf_sccp_xudt_msg_fragment_count;

static int hf_sccp_xudt_msg_reassembled_in;

static int hf_sccp_xudt_msg_reassembled_length;

static int hf_sccp_assoc_msg;

static int hf_sccp_assoc_id;

static int hf_sccp_segmented_data;

static int hf_sccp_linked_dissector;

static int hf_sccp_end_optional_param;

static int hf_sccp_unknown_message;

static int hf_sccp_unknown_parameter;

/* Initialize the subtree pointers */

static int ett_sccp;

static int ett_sccp_called;

static int ett_sccp_called_ai;

static int ett_sccp_called_pc;

static int ett_sccp_called_gt;

static int ett_sccp_called_gt_digits;

static int ett_sccp_calling;

static int ett_sccp_calling_ai;

static int ett_sccp_calling_pc;

static int ett_sccp_calling_gt;

static int ett_sccp_calling_gt_digits;

static int ett_sccp_sequencing_segmenting;

static int ett_sccp_segmentation;

static int ett_sccp_ansi_isni_routing_control;

static int ett_sccp_xudt_msg_fragment;

static int ett_sccp_xudt_msg_fragments;

static int ett_sccp_assoc;

static expert_field ei_sccp_wrong_length;

static expert_field ei_sccp_international_standard_address;

static expert_field ei_sccp_no_ssn_present;

static expert_field ei_sccp_ssn_zero;

static expert_field ei_sccp_class_unexpected;

static expert_field ei_sccp_handling_invalid;

static expert_field ei_sccp_gt_digits_missing;

static expert_field ei_sccp_externally_reassembled;

static bool sccp_reassemble = true;

static bool show_key_params;

static bool set_addresses;

static bool dt1_ignore_length;

static int ss7pc_address_type = -1;

static int sccp_tap;

static const fragment_items sccp_xudt_msg_frag_items = {

  /* Fragment subtrees */

  &ett_sccp_xudt_msg_fragment,

  &ett_sccp_xudt_msg_fragments,

  /* Fragment fields */

  &hf_sccp_xudt_msg_fragments,

  &hf_sccp_xudt_msg_fragment,

  &hf_sccp_xudt_msg_fragment_overlap,

  &hf_sccp_xudt_msg_fragment_overlap_conflicts,

  &hf_sccp_xudt_msg_fragment_multiple_tails,

  &hf_sccp_xudt_msg_fragment_too_long_fragment,

  &hf_sccp_xudt_msg_fragment_error,

  &hf_sccp_xudt_msg_fragment_count,

  /* Reassembled in field */

  &hf_sccp_xudt_msg_reassembled_in,

  /* Reassembled length field */

  &hf_sccp_xudt_msg_reassembled_length,

  /* Reassembled data field */

  NULL,

  /* Tag */

  "SCCP XUDT Message fragments"

};

static reassembly_table sccp_xudt_msg_reassembly_table;

#define SCCP_USER_DATA       0

#define SCCP_USER_TCAP       1

#define SCCP_USER_RANAP      2

#define SCCP_USER_BSSAP      3

#define SCCP_USER_GSMMAP     4

#define SCCP_USER_CAMEL      5

#define SCCP_USER_INAP       6

#define SCCP_USER_BSAP       7

#define SCCP_USER_BSSAP_LE   8

#define SCCP_USER_BSSAP_PLUS 9

typedef struct _sccp_user_t {

  unsigned            ni;

  range_t            *called_pc;

  range_t            *called_ssn;

  unsigned            user;

  bool                uses_tcap;

  dissector_handle_t *handlep;

} sccp_user_t;

static sccp_user_t *sccp_users;

static unsigned     num_sccp_users;

static dissector_handle_t sccp_handle;

static dissector_handle_t data_handle;

static dissector_handle_t tcap_handle;

static dissector_handle_t ranap_handle;

static dissector_handle_t bssap_handle;

static dissector_handle_t gsmmap_handle;

static dissector_handle_t camel_handle;

static dissector_handle_t inap_handle;

static dissector_handle_t bsap_handle;

static dissector_handle_t bssap_le_handle;

static dissector_handle_t bssap_plus_handle;

static dissector_handle_t default_handle;

static const char *default_payload;

static const value_string sccp_users_vals[] = {

  { SCCP_USER_DATA,       "Data"},

  { SCCP_USER_TCAP,       "TCAP"},

  { SCCP_USER_RANAP,      "RANAP"},

  { SCCP_USER_BSSAP,      "BSSAP"},

  { SCCP_USER_GSMMAP,     "GSM MAP"},

  { SCCP_USER_CAMEL,      "CAMEL"},

  { SCCP_USER_INAP,       "INAP"},

  { SCCP_USER_BSAP,       "BSAP"},

  { SCCP_USER_BSSAP_LE,   "BSSAP-LE"},

  { SCCP_USER_BSSAP_PLUS, "BSSAP+"},

  { 0, NULL }

};

/*

 * Here are the global variables associated with

 * the various user definable characteristics of the dissection

 */

static uint32_t sccp_source_pc_global;

static bool sccp_show_length;

static bool trace_sccp;

static heur_dissector_list_t heur_subdissector_list;

static dissector_table_t sccp_ssn_dissector_table;

static wmem_tree_t       *assocs;

static sccp_assoc_info_t  no_assoc = { 0,0,0,INVALID_SSN,INVALID_SSN,false,false,NULL,NULL,SCCP_PLOAD_NONE,NULL,NULL,NULL, NULL, 0 };

static uint32_t           next_assoc_id;

static const value_string assoc_protos[] = {

  { SCCP_PLOAD_BSSAP,   "BSSAP" },

  { SCCP_PLOAD_RANAP,   "RANAP" },

  { 0,                  NULL }

};

/*

 * Fragment reassembly helpers.

 *

 * SCCP data can span multiple messages. As the same local reference number is

 * used throughout a connection, this identifier is not sufficient for

 * identifying reassembled PDUs with multiple fragments in the same frame. For

 * that reason, create a new identifier for each group of fragments based on the

 * more-data indicator (M-bit) and use that in place of the local reference

 * number.

 *

 * As an optimization, if fragments do not need reassembly (a single message

 * with the M-bit set), then no surrogate ID is needed nor stored since

 * reassembly is skipped.

 */

static uint32_t sccp_reassembly_id_next;

/* Maps a key to the current identifier as used in the reassembly API (first pass only). */

static wmem_tree_t *sccp_reassembly_ids;

/* Maps (frame number, offset) to a reassembly API identifier. */

static wmem_map_t *sccp_reassembly_id_map;

static uint32_t

sccp_reassembly_get_id_pass1(uint32_t frame, uint32_t offset, uint32_t key, bool more_frags)

{

  uint32_t id = GPOINTER_TO_UINT(wmem_tree_lookup32(sccp_reassembly_ids, key));

  if (!id) {

    if (!more_frags) {

      /* This is the last and only fragment, no need to reassembly anything. */

      return 0;

    }

    /* This is a new fragment and "local reference", so create a new one. */

    id = sccp_reassembly_id_next++;

    wmem_tree_insert32(sccp_reassembly_ids, key, GUINT_TO_POINTER(id));

  }

  /* Save ID for second pass. */

  uint64_t *frame_offset = wmem_new(wmem_file_scope(), uint64_t);

  *frame_offset = ((uint64_t)offset << 32) | frame;

  wmem_map_insert(sccp_reassembly_id_map, frame_offset, GUINT_TO_POINTER(id));

  return id;

}

static uint32_t

sccp_reassembly_get_id_pass2(uint32_t frame, uint32_t offset)

{

  uint64_t frame_offset = ((uint64_t)offset << 32) | frame;

  return GPOINTER_TO_UINT(wmem_map_lookup(sccp_reassembly_id_map, &frame_offset));

}

/**

 * Returns the reassembly ID for the given frame at the given position or 0 if

 * reassembly is not necessary.

 */

static uint32_t

sccp_reassembly_get_id(packet_info *pinfo, uint32_t offset, uint32_t key, bool more_frags)

{

  if (!PINFO_FD_VISITED(pinfo)) {

    return sccp_reassembly_get_id_pass1(pinfo->num, offset, key, more_frags);

  } else {

    return sccp_reassembly_get_id_pass2(pinfo->num, offset);

  }

}

static tvbuff_t *

sccp_reassemble_fragments(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                          uint16_t length_offset, uint32_t source_local_ref, bool more_frags,

                          uint8_t pointer_length)

{

  bool      save_fragmented;

  tvbuff_t *new_tvb;

  fragment_head *frag_msg = NULL;

  unsigned  fragment_len;

  uint32_t  abs_offset, frags_id;

  switch (pointer_length) {

  case POINTER_LENGTH:

    fragment_len = tvb_get_uint8(tvb, length_offset);

    break;

  case POINTER_LENGTH_LONG:

    fragment_len = tvb_get_uint16(tvb, length_offset, ENC_LITTLE_ENDIAN);

    break;

  default:

    ws_assert_not_reached();

  }

  /* Assume that the absolute offset within the tvb uniquely identifies the

   * message in this frame. */

  abs_offset = tvb_raw_offset(tvb) + length_offset;

  frags_id = sccp_reassembly_get_id(pinfo, abs_offset, source_local_ref, more_frags);

  if (frags_id) {

    /*

     * This fragment is part of multiple fragments, reassembly is required.

     */

    save_fragmented = pinfo->fragmented;

    pinfo->fragmented = true;

    frag_msg = fragment_add_seq_next(&sccp_xudt_msg_reassembly_table,

                                     tvb, length_offset + pointer_length,

                                     pinfo,

                                     frags_id,        /* ID for fragments belonging together */

                                     NULL,

                                     fragment_len,    /* fragment length - to the end */

                                     more_frags);     /* More fragments? */

    if (!PINFO_FD_VISITED(pinfo) && frag_msg) {

      /* Reassembly has finished, ensure that the next fragment gets a new ID. */

      wmem_tree_remove32(sccp_reassembly_ids, source_local_ref);

    }

    new_tvb = process_reassembled_data(tvb, length_offset + pointer_length, pinfo,

                                       "Reassembled SCCP", frag_msg,

                                       &sccp_xudt_msg_frag_items,

                                       NULL, tree);

    if (frag_msg) { /* Reassembled */

      col_append_str(pinfo->cinfo, COL_INFO, "(Message reassembled) ");

    } else { /* Not last packet of reassembled message */

      col_append_str(pinfo->cinfo, COL_INFO, "(Message fragment) ");

    }

    pinfo->fragmented = save_fragmented;

  } else {

    /*

     * There is only a single fragment, reassembly is not required.

     */

    new_tvb = tvb_new_subset_length(tvb, length_offset + pointer_length, fragment_len);

  }

  return new_tvb;

}

#define is_connectionless(m) \

  ( m == SCCP_MSG_TYPE_UDT || m == SCCP_MSG_TYPE_UDTS      \

    || m == SCCP_MSG_TYPE_XUDT|| m == SCCP_MSG_TYPE_XUDTS  \

    || m == SCCP_MSG_TYPE_LUDT|| m == SCCP_MSG_TYPE_LUDTS)

#define RETURN_FALSE \

  do { \

    /*ws_warning("Frame %d not protocol %d @ line %d", frame_num, my_mtp3_standard, __LINE__);*/ \

    return false; \

  } while (0)

static void sccp_prompt(packet_info *pinfo _U_, char* result)

{

  snprintf(result, MAX_DECODE_AS_PROMPT_LEN, "Dissect SSN %d as",

     GPOINTER_TO_UINT(p_get_proto_data(pinfo->pool, pinfo, proto_sccp, 0)));

}

static void *sccp_value(packet_info *pinfo)

{

  return p_get_proto_data(pinfo->pool, pinfo, proto_sccp, 0);

}

static bool

sccp_called_calling_looks_valid(uint32_t frame_num _U_, tvbuff_t *tvb, uint8_t my_mtp3_standard, bool is_co)

{

  uint8_t ai, ri, gti, ssni, pci;

  uint8_t len_needed = 1;      /* need at least the Address Indicator */

  unsigned  len        = tvb_reported_length(tvb);

  ai = tvb_get_uint8(tvb, 0);

  if ((my_mtp3_standard == ANSI_STANDARD) && ((ai & ANSI_NATIONAL_MASK) == 0))

    RETURN_FALSE;

  gti = (ai & GTI_MASK) >> GTI_SHIFT;

  if (my_mtp3_standard == ANSI_STANDARD) {

    if (gti > 2)

      RETURN_FALSE;

  } else {

    if (gti > 4)

      RETURN_FALSE;

  }

  ri = (ai & ROUTING_INDICATOR_MASK) >> ROUTING_INDICATOR_SHIFT;

  if (my_mtp3_standard == ANSI_STANDARD) {

    pci  = ai & ANSI_PC_INDICATOR_MASK;

    ssni = ai & ANSI_SSN_INDICATOR_MASK;

  } else {

    ssni = ai & ITU_SSN_INDICATOR_MASK;

    pci  = ai & ITU_PC_INDICATOR_MASK;

  }

  /* Route on SSN with no SSN? */

  if ((ri == ROUTE_ON_SSN) && (ssni == 0))

    RETURN_FALSE;

  /* Route on GT with no GT? */

  if ((ri == ROUTE_ON_GT) && (gti == AI_GTI_NO_GT))

    RETURN_FALSE;

  /* GT routed and connection-oriented (Class-2)?

   * Yes, that's theoretically possible, but it's not used.

   */

  if ((ri == ROUTE_ON_GT) && is_co)

    RETURN_FALSE;

  if (ssni)

    len_needed += ADDRESS_SSN_LENGTH;

  if (pci) {

    if (my_mtp3_standard == ANSI_STANDARD ||

        my_mtp3_standard == CHINESE_ITU_STANDARD)

      len_needed += ANSI_PC_LENGTH;

    else

      len_needed += ITU_PC_LENGTH;

  }

  if (gti)

    len_needed += 2;

  if (len_needed > len)

    RETURN_FALSE;

  return true;

}

bool

looks_like_valid_sccp(uint32_t frame_num _U_, tvbuff_t *tvb, uint8_t my_mtp3_standard)

{

  unsigned  offset;

  uint8_t msgtype, msg_class, cause;

  unsigned  called_ptr     = 0;

  unsigned  calling_ptr    = 0;

  unsigned  data_ptr       = 0;

  unsigned  opt_ptr        = 0;

  uint8_t pointer_length = POINTER_LENGTH;

  unsigned  len            = tvb_captured_length(tvb);

  /* Ensure we can do some basic checks without throwing an exception.

   * Accesses beyond this length need to check the length first because

   * we don't want to throw an exception in here...

   */

  if (len < 5)

    RETURN_FALSE;

  msgtype = tvb_get_uint8(tvb, SCCP_MSG_TYPE_OFFSET);

  if (!try_val_to_str(msgtype, sccp_message_type_acro_values)) {

    RETURN_FALSE;

  }

  offset = SCCP_MSG_TYPE_LENGTH;

  switch (msgtype) {

  case SCCP_MSG_TYPE_UDT:

  case SCCP_MSG_TYPE_XUDT:

  case SCCP_MSG_TYPE_LUDT:

  case SCCP_MSG_TYPE_UDTS:

  case SCCP_MSG_TYPE_XUDTS:

  case SCCP_MSG_TYPE_LUDTS:

  {

    if (msgtype == SCCP_MSG_TYPE_XUDT || msgtype == SCCP_MSG_TYPE_XUDTS) {

      if (SCCP_MSG_TYPE_LENGTH +